poj 1151

分类： 线段树

题意： 求矩阵面积并

输入： 矩阵个数N，每个矩阵的左下角坐标和右上角坐标

输出： 矩阵的面积并

很久没有做数据结构了，这道题算是比较经典，难度相对适中的吧，今天拿出来写了一遍。数据结构主要是线段树。虽然写过几次了，每次动手写都会遇到一些问题。做个笔记：

1.基本算法：

将矩形沿着Y方向的平行于X轴的线作为扫描线。核心算法在于对于n – 1条扫描线作的高度差用来算矩阵的面积

上面两张是比较好理解的图（来自网络）。线段树的作用就在于保存当前的X轴覆盖区域的长度为多少，每一次，顺着扫描方向，插入一段扫描线更新当前的覆盖区域长度（会有重合）。

一个技巧：把下边的边flag设置为true，上面的边设置为false，然后在线段树中记录有多少个覆盖记录，以方便计算

2.去重与排序

可以用STL的unique，当然也可以手写，排序也是不可缺少的，本题数据量而言，时间复杂度是完全可以满足的

3.二分查找

一种映射关系，因为x坐标是浮点数，所以不可以直接离散化，需要一种映射

4.树的写法

node需要携带什么信息？如何建树和存储？

重点中的重点：插入线段的时候应该如何处理？

                            如何更新？

 

#include <iostream>
#include <vector>
#include <map>
#include <list>
#include <set>
#include <deque>
#include <stack>
#include <queue>
#include <algorithm>
#include <cmath>
#include <cctype>
#include <cstdio>
#include <iomanip>
#include <cmath>
#include <cstdio>
#include <iostream>
#include <string>
#include <sstream>
#include <cstring>
#include <queue>
using namespace std;

///宏定义
const int  INF = 990000000;
const int MAXN = 2000;
const int maxn = MAXN;
///全局变量 和 函数

struct line
{
    double ypos;
    double xleftPos, xrightPos;
    bool flag;
    bool operator < (const line& l)
    {
        return ypos < l.ypos;
    }
};

struct node
{
    int lchild, rchild;
    int ll, rr;
    double length;
    int cover;
};
double xpos[maxn];

void buildTree(int left, int right, int cur, node* T)
{
    T[cur].ll = left;
    T[cur].rr = right;
    T[cur].length = 0;
    if (right - left == 1)
    {
        T[cur].lchild = T[cur].rchild = -1;
        return;
    }
    T[cur].lchild = 2 * cur;
    T[cur].rchild = 2 * cur + 1;    
    int mid = (left + right) / 2;
    buildTree(left, mid, 2 * cur, T);
    buildTree(mid, right, 2 * cur + 1, T);
}
node tree[maxn * 4];

line lines[maxn];

void update(node* T, int cur, bool flag)
{
    if (T[cur].lchild == -1 && T[cur].rchild == -1)
    {
        int L = T[cur].ll;
        int R = T[cur].rr;
        if (flag)
        {
            T[cur].cover++;
            if (T[cur].cover == 1)
            {
                T[cur].length += xpos[R - 1] - xpos[L - 1];  //注意xpos数组的下标 
            }            
        }
        else if(!flag)
        {
            T[cur].cover--;
            if (T[cur].cover == 0)
            {
                T[cur].length -= xpos[R - 1] - xpos[L - 1];  //注意xpos数组的下标
            }            
        }
        return;
    }
    else
        T[cur].length = T[cur * 2].length + T[cur * 2 + 1].length;
}
void insert(node* T, int cur, int Left, int Right, bool flag)
{
    if (T[cur].lchild == -1 && T[cur].rchild == -1)
    {

    }
    else
    {
        int mid = (T[cur].ll + T[cur].rr) / 2;
        if (Right <= mid)
        {    
            insert(T, cur * 2, Left, Right, flag);
        }
        else if (Left >= mid)
        {
            insert(T, cur * 2 + 1, Left, Right, flag);
        }
        else
        {
            insert(T, cur * 2, Left, mid, flag);
            insert(T, cur * 2 + 1, mid, Right, flag);
        }
    }
    update(T, cur, flag);
}

int b_search(double *arr, int n, double val);
int main()
{
    ///变量定义
    int n;
    int cases = 1;
    while (scanf("%d", &n) && n != 0)
    {
        double area = 0;
        memset(tree, 0, sizeof(tree));
        int lineNum = 0;
        int xposNum = 0;
        for (int i = 0; i < n; i++)
        {
            double x1, y1, x2, y2;
            scanf("%lf %lf %lf %lf", &x1, &y1, &x2, &y2);
            lines[lineNum].ypos = y1;
            lines[lineNum].xleftPos = x1;
            lines[lineNum].xrightPos = x2;
            lines[lineNum].flag = true;
            lineNum++;

            lines[lineNum].ypos = y2;
            lines[lineNum].xleftPos = x1;
            lines[lineNum].xrightPos = x2;
            lines[lineNum].flag = false;
            lineNum++;

            xpos[xposNum++] = x1;
            xpos[xposNum++] = x2;
        }
        sort(lines, lines + lineNum);
        sort(xpos, xpos + xposNum);
        int k = 0;
        for (int i = 1; i < xposNum; i++)
        {
            if (xpos[i] != xpos[k])
            {
                xpos[++k] = xpos[i];
            }
        }
        xposNum = k + 1;
        sort(xpos, xpos + xposNum);

        //建立线段树
        buildTree(1, xposNum, 1, tree);

        for (int i = 0; i < lineNum - 1; i++)
        {
            //找到下标
            int ll = b_search(xpos, xposNum, lines[i].xleftPos);
            int rr = b_search(xpos, xposNum, lines[i].xrightPos);
            bool flag = lines[i].flag;
            //插入到线段树
            insert(tree, 1, ll + 1, rr + 1, flag);            

            //
            area += (lines[i + 1].ypos - lines[i].ypos) * tree[1].length;
        }
        printf("Test case #%d\n", cases++);
        printf("Total explored area: %.2f\n\n", area);
    }

    ///结束
    return 0;
}

int b_search(double *arr, int n, double val)
{
    int low = 0;
    int high = n - 1;
    int mid;
    while (low <= high)
    {
        mid = (low + high) >> 1;
        if (arr[mid] == val)
        {
            return mid;
        }
        else if (arr[mid] > val)
        {
            high = mid - 1;
        }
        else
        {
            low = mid + 1;
        }
    }
    return -1;
}