HDU1542线段树面积并

HDU 1542

题意：给你多组数据，每组数据每行代表一个矩形的左下标和右上标；计算每组数据的面积，重叠面积也只算一次。

这里采用的是线段树算法。由于题意中给出的坐标都是带小数的，先前线段树都是整型，所以就有了离散化这个词。翻阅了很多大大们对离散化扫描线的理解，最早是从http://www.cnblogs.com/scau20110726/archive/2013/03/21/2972808.html这个大大的理解领悟的。

这里我离散化的是X坐标，也就是说，扫描线从下往上。
这里对样例数据做分析：
10 10 20 20
15 15 25 25.5 我们对所有平行于X轴的X坐标存至数组并排序，那么就会有序列 10 10 15 15 20 20 25 25
包括上边和下边 如图

所以整个要计算的X最大区间就是10到25，去掉重复的值后序列就变成了 10 15 20 25 一共四个点

所以我们就可以离散化成 1 - 4 其中 (1~2)代表 （10->15） (2~3)代表（15->20）..以此类推，那这样是不是就有点像线段树的操作了，也就是说，单独用一个数组来专门记录X所有的实际值，然后排序去重，给每个实际值都赋与一个下标对应线段树区间。至此离散化操作完成了。接下来就完成一半的难题了，线段树建立起来了。那怎么求面积并？

其实要求面积并的话百度一下，大大们都讲的很明白了。上面只提到X坐标，那么Y坐标呢？既然我们已经把所有的X坐标都离散化了，那么只有给出一个变的左右X坐标是不是就可以知道这条边在线段树中的范围。所以我们结构一个边信息，只要记录这条边的左右端点X坐标，高以及这条边是上边还是下边。这样接下来的操作就没啥想不通的。上边我们标记1 下边我们标记-1；
如图：
我们想象出了一条扫描线，并且结构体一个扫描线，记录区间有效长度，每扫描到一条边就更新一次区间的有效长度，并用每次的有效长度乘以这条边与下一条边的高度差，就是一块一块的面积，直到最后第n-1条整个算法结束。说的不清楚。自己需要画图比较明白。

当扫描线碰到第一条边的时候，首先找这条边的区间，并更新这个区间的有效长度。更新是有条件的，如果这个区间的有效长度的标记cnt大于0那就说明有重边，如果有重边，有效长度就是这个区间的X端点差，否则就是这个区间的子区间长度和。这段说的还是不清晰，但是是关键为什么线段树可以计算面积并的原因所在。


综上就是有两个结构体分别意义为 边信息 和 区间有效长度。上代码结合一下看吧。。说的好乱。。=。=

#include<iostream>
#include<algorithm>
#include<fstream>
//#pragma comment(linker, "/STACK:1024000000,1024000000") 
using namespace std;

const int MAX = 200000;


struct TRI
{
    double l, r;//这条边的左右端点
    double h;//高
    int flag;//上边为-1 下边为 1
}edge[MAX];

double node[MAX];


//这个结构体记录的是区间有效长度
struct S
{
    double sum;//有效长度
    int cnt;//大于0就说明有两个1，有边重了
}sum[MAX << 1];

bool cp(TRI a, TRI b)
{
    return a.h < b.h;
}

void built(int root, double l, double r, double h, int flag)
{
    edge[root].l = l;
    edge[root].r = r;
    edge[root].h = h;
    edge[root].flag = flag;
}


//二分查找这个X端点离散化后的范围,就是  10 被离散成 1了
int find(int L, int R, double ch)
{
    int l = L, r = R;
    while (l<r)
    {
        int mid = (l + r) >> 1;
        if (ch>node[mid]) l = mid + 1;
        else if (ch == node[mid]) return mid;
        else
            r = mid - 1;
    }
}

//每次操作都会更新区间有效长度，保证最大区间的有效长度始终是有用的
void pushup(int root, int l, int r)
{
    if (sum[root].cnt)//大于0说明重边，重边有效长度就直接是这条区间端口差
        sum[root].sum = node[r] - node[l];
    else if (l == r)//元线段，当然就是0了
        sum[root].sum = 0;
    else//否则就是子区间和
        sum[root].sum = sum[root << 1].sum + sum[root << 1 | 1].sum;
}

void updata(int root, int L, int R, int l, int r, int flag)
{
    if (L >= l && R <= r)
    {
        sum[root].cnt += flag;
        pushup(root, L, R);
        return;
    }
    if (l == r)
        return;
    int mid = (L + R) >> 1;
    if (r <= mid)
        updata(root << 1, L, mid, l, r, flag);
    else if (l > mid)
        updata(root << 1 | 1, mid, R, l, r, flag);
    else{
        updata(root << 1, L, mid, l, mid, flag);
        updata(root << 1 | 1, mid, R, mid, r, flag);
    }
    pushup(root,L,R);
}

void init()
{
    memset(node, 0, sizeof(node));
    for (int i = 0; i < MAX; i++)
    {
        sum[i].cnt = 0;
        sum[i].sum = 0;
    }
}

int main()
{
    int t;
    int tt = 1;
    //fstream fin("t.txt");
    while (cin >> t,t)
    {
        init();
        for (int i = 1; i <= t; i++)
        {
            double a, b, c, d;
            cin >> a >> b >> c >> d;
            built((i << 1)-1, a, c, b, 1);
            built((i << 1 | 1)-1, a, c, d, -1);
            node[(i << 1)-1] = a;
            node[(i << 1 | 1)-1] = c;
        }
        //对边排序
        sort(edge + 1, edge + 1 + 2 * t, cp);
        //对点排序|
        sort(node + 1, node + 1 + 2 * t);
        //X端点去重
        int m = 1;
        for (int i = 2; i <= 2 * t ; i++)
        {
            if (node[i] != node[m]) node[++m] = node[i];
        }
        double area = 0;
        for (int i = 1; i <= 2 * t; i++)
        {
            //离散化在这，把double转成用int来表示区间
            int l = find(1, m, edge[i].l);
            int r = find(1, m, edge[i].r);
            if (l < r) updata(1,1,m,l,r,edge[i].flag);
            area += sum[1].sum * (edge[i+1].h - edge[i].h);
        }
        //cout << "Test case #" << tt++ << "\nTotal explored area : " << area << endl;
        printf("Test case #%d\nTotal explored area: %.2lf\n\n", tt++, area);
    }
    return 0;
}