HDU 1542 - Atlantis（矩形面积并：离散化+线段树+扫描线）

算法详解： https://blog.csdn.net/tomorrowtodie/article/details/52048323

【题意】
平面直角坐标系上给定n个矩形，每个矩形用左下角坐标(x1,y1)和右上角坐标(x2,y2)描述，求这些矩形覆盖的总面积是多少

【思路】
线段树和扫描线的经典应用，看了别人的博客学会的，如果从下往上扫描的话，就要对横坐标离散化处理，然后根据横坐标离散化后的下标来建立线段树，线段树每个结点的[L,R]区间对应真正坐标系上X[L]~X[R+1]的部分，下面是我按照自己的习惯写了一遍

#include<bits/stdc++.h>
using namespace std;
#define node tree[id]
#define lson tree[id<<1]
#define rson tree[id<<1|1]
const int maxn=105;

struct Edge{
    double le,ri;   //一条边的左右端点
    double h;       //纵坐标
    int flag;       //-1为上边，1为下边
    Edge(double l=0,double r=0,double hh=0,int f=0):le(l),ri(r),h(hh),flag(f){}
    bool operator<(const Edge& e)const{
        return h<e.h;
    }
};

struct Tree{
    int left,right;
    double len;     //当前区间的有效长度
    int cover;      //cover!=0说明区间被完全覆盖
};

int n;
vector<double> x;
vector<Edge> edges;
Tree tree[maxn<<3];

void pushup(int id){
    if(node.cover) node.len=x[node.right+1]-x[node.left];
    else if(node.left==node.right) node.len=0;
    else node.len=lson.len+rson.len;
}

void build(int id,int le,int ri){
    node.left=le;
    node.right=ri;
    node.len=0;
    node.cover=0;
    if(le==ri) return;
    int mid=(le+ri)>>1;
    build(id<<1,le,mid);
    build(id<<1|1,mid+1,ri);
}

void update(int id,int le,int ri,int tp){
    if(node.left==le && node.right==ri){
        node.cover+=tp;
        pushup(id);
        return;
    }
    int mid=(node.left+node.right)>>1;
    if(ri<=mid) update(id<<1,le,ri,tp);
    else if(le>mid) update(id<<1|1,le,ri,tp);
    else{
        update(id<<1,le,mid,tp);
        update(id<<1|1,mid+1,ri,tp);
    }
    pushup(id);
}

int main(){
    int kase=1;
    while(scanf("%d",&n)==1 && n){
        x.clear();
        edges.clear();
        for(int i=0;i<n;++i){
            double x1,y1,x2,y2;//(x1,y1)为左下角,(x2,y2)为右上角
            scanf("%lf%lf%lf%lf",&x1,&y1,&x2,&y2);
            Edge e=Edge(x1,x2,y1,1);
            edges.push_back(e);
            e=Edge(x1,x2,y2,-1);
            edges.push_back(e);
            x.push_back(x1);
            x.push_back(x2);
        }
        sort(x.begin(),x.end());
        x.erase(unique(x.begin(),x.end()),x.end());
        int cnt=x.size();
        build(1,0,cnt-1);

        sort(edges.begin(),edges.end());
        double ans=0;
        for(int i=0;i<edges.size()-1;++i){
            int le=lower_bound(x.begin(),x.end(),edges[i].le)-x.begin();
            int ri=lower_bound(x.begin(),x.end(),edges[i].ri)-x.begin()-1;
            update(1,le,ri,edges[i].flag);
            ans+=tree[1].len*(edges[i+1].h-edges[i].h);
        }
        printf("Test case #%d\n",kase++);
        printf("Total explored area: %.2f\n\n",ans);
    }
    return 0;
}