HDU - 1542 Atlantis（区间修改，扫描线，离散化）

HDU - 1542 Atlantis

题目

在平面上给出 n 个矩形，求矩形并的面积。

分析

首先用扫描线按矩形的水平边分段，如上图。在同一段的面积一起计算，即同一种颜色。

具体操作：
从下往上扫描，对于每一段的高，即为两个相邻的水平边之间的垂直距离。

而对于每一段的宽，就是多个矩形的实际覆盖距离，这一部分用线段树的区间覆盖来维护。

如果扫到的这条边是某矩形的下边，则往区间插入这条线段

如果扫到的这条边是某矩形的上边，则往区间删除这条线段

就可以得到当前的那一段的实际覆盖距离。

将每一段面积相加即为结果。

小技巧：这里如果坐标太大，要用到离散化，只不过运算的时候还是以真实值运算，但在线段树里是离散化过的值。

#define lson l, m, rt<<1
#define rson m+1, r, rt<<1|1

#include 
using namespace std;
typedef long long ll;
const ll mod = 9999991;
const int N = 2e5 + 10;

int n, cas = 1, cnt;
double tmp[N];        //离散化数组
int col[N];
double tr[N];         //区间实际覆盖距离
struct node{          //矩形的上下两条线段
    double l, r, h;   //线段左右端点，高
    int s;            //线段是矩形上边还是下边
    node(){}
    node(double l, double r, double h, int s):l(l),r(r),h(h),s(s){}
    bool operator < (const node & b) const{
        return h < b.h;
    }
} seg[N];

void pushup(int rt, int l, int r){
    if(col[rt]){            //如果有区间覆盖标记，实际覆盖长度为 tmp数组差值
        tr[rt] = tmp[r + 1] - tmp[l];
    }else if(l == r){
        tr[rt] = 0;
    }else{                  //没的话就是左右区间有效长度相加
        tr[rt] = tr[rt << 1] + tr[rt << 1 | 1];
    }
}

void update(int L, int R, int c, int l, int r, int rt){
    if(L <= l && r <= R){
        col[rt] += c;
        pushup(rt, l, r);
        return;
    }
    int m = l + r >> 1;
    if(L <= m){
        update(L, R, c, lson);
    }
    if(R > m){
        update(L, R, c, rson);
    }
    pushup(rt, l, r);
}

int main()
{
    while(~scanf("%d", &n) && n){
        cnt = 0;
        while(n--){
            double a, b, c, d;
            scanf("%lf%lf%lf%lf", &a, &b, &c, &d);
            tmp[cnt] = a;                       // tmp 数组存 x 坐标，线段树以 x 坐标建树
            seg[cnt++] = node(a, c, b, 1);      // seg 数组存矩形的每一条水平边，下边为1，上边为-1
            tmp[cnt] = c;
            seg[cnt++] = node(a, c, d, -1);
        }
        sort(tmp, tmp + cnt);
        sort(seg, seg + cnt);                   //按高度排序
        int k = 1;                                      
        for (int i = 1; i < cnt; i++){          //去重，便于后面离散化
            if(tmp[i] != tmp[i-1]){             //默认 tmp[0] 排好了，从 1 开始
                tmp[k++] = tmp[i];
            }
        }
        memset(col, 0, sizeof(col));
        memset(tr, 0, sizeof(tr));
        double ans = 0;
        for (int i = 0; i < cnt - 1; i++){      //每次处理一段的面积， 处理 cnt - 1段
            int l = upper_bound(tmp, tmp + k, seg[i].l) - tmp - 1;
            int r = upper_bound(tmp, tmp + k, seg[i].r) - tmp - 2;
            if (l <= r){
                update(l, r, seg[i].s, 0, k - 1, 1);
            }
            ans += tr[1] * (seg[i + 1].h - seg[i].h);
        }
        printf("Test case #%d\nTotal explored area: %.2lf\n\n", cas++, ans);
    }
    return 0;
}