POJ 1151 Atlantis（扫描线）

题意：给你n个矩形，每个矩形给出左下点的坐标，右上点的坐标。最后以n=0为结束。要你求出矩形并后的面积。

         扫描线。 在陈宏的论文里这么定义超元线段：根据每个矩形纵向边的横坐标纵向地对平面进行2*n次切割、根据矩形横向边的纵坐标横向地对矩形进行2*n次切割（n为矩形个数），切割后得到的矩形的被切割后的小段边就是超元线段。

         现在我们仅考虑未被横向的边切割的超元线段（即矩形纵向的边），这些边上的直线把矩形分成这2*n-1块区域，而这些区域的面积和也就是矩形并后的面积。

         如何求每一块区域的面积呢？长可以通过两条相邻的超元线段的x坐标差得到（即line[i].x-line[i-1].x）。如果求出宽呢？

         宽就是line[i]之前（不包括i）的所有线段全部投影到y轴上得到的长度，也就是说我们求出y轴上被覆盖的区域的长度即可。

         而这个的实现方法是用维段树去维护。当我们从左往右不断地将线段放入线段树以求得在y轴上投影得到的区域的长度时，我们把同一个矩形左边的边的权值设置为1（表示覆盖），右边的边设置为-1（表示撤消覆盖）。这样就能实现对y轴上投影的更新，因为这是假想有一根线去不断地从左往右扫，所以叫扫描线。

         但是还要注意，如果给出的矩形的范围太大，如果10^9那么我们要对它进行离散化，即在线段树的节点里增加两个变量，表示这条线段真正的端点，而原来的两个变量表示在线段树中的端点。在建树的时候还有点变化即(left,mid),(mid,right)，因为节点里存放的是线段，不是点。

/*代码风格更新后*/
#include <iostream>
#include <cstdio>
#include <cstring>
#include <vector>
#include <algorithm>
#include <map>
using namespace std;

#define LL(x) (x<<1)
#define RR(x) (x<<1|1)
#define MID(a,b) (a+((b-a)>>1))
const int N=205;

struct Line
{
    int flag;
    double x,y1,y2;
    Line(){}
    Line(double a,double b,double c,int d)
    { x=a;y1=b;y2=c;flag=d; }
    bool operator<(const Line &b)const
    { return x<b.x; }
};
struct node
{
    int lft,rht,flag;
    double ll,rr,len;
    int mid(){return MID(lft,rht);}
    void fun(int valu)
    {
        flag+=valu;
        if(flag==0) len=0;
        else len=rr-ll;
    }
};

vector<double> y;
vector<Line> line;
map<double,int> H;

struct Segtree
{
    node tree[N*4];
    void build(int lft,int rht,int ind)
    {
        tree[ind].lft=lft;    tree[ind].rht=rht;
        tree[ind].flag=0;    tree[ind].len=0;
        tree[ind].ll=y[lft];    tree[ind].rr=y[rht];
        if(lft+1!=rht)
        {
            int mid=tree[ind].mid();
            build(lft,mid,LL(ind));
            build(mid,rht,RR(ind));
        }
    }
    void updata(int st,int ed,int ind,int valu)
    {
        int lft=tree[ind].lft,rht=tree[ind].rht;
        if(lft+1==rht) tree[ind].fun(valu);
        else
        {
            int mid=tree[ind].mid();
            if(st<mid) updata(st,ed,LL(ind),valu);
            if(ed>mid) updata(st,ed,RR(ind),valu);
            tree[ind].len=tree[LL(ind)].len+tree[RR(ind)].len;
        }
    }
}seg;
int main()
{
    int n,t_cnt=0;
    while(scanf("%d",&n)&&n)
    {
        H.clear(); line.clear(); y.clear();

        double x1,y1,x2,y2;
        for(int i=1;i<=n;i++)
        {
            scanf("%lf%lf%lf%lf",&x1,&y1,&x2,&y2);
            line.push_back(Line(x1,y1,y2,1));
            line.push_back(Line(x2,y1,y2,-1));
            y.push_back(y1); y.push_back(y2);
        }

        sort(line.begin(),line.end());
        sort(y.begin(),y.end());
        y.erase(unique(y.begin(),y.end()),y.end());

        for(int i=0;i<(int)y.size();i++) H[y[i]]=i;
        seg.build(0,(int)y.size()-1,1);

        double res=0;
        printf("Test case #%d\n",++t_cnt);
        for(int i=0;i<(int)line.size();i++)
        {
            if(i!=0) res+=(line[i].x-line[i-1].x)*seg.tree[1].len;
            seg.updata(H[line[i].y1],H[line[i].y2],1,line[i].flag);
        }
        printf("Total explored area: %.2lf\n\n",res);
    }
    return 0;
}

/*代码风格更新前*/
#include <iostream>
#include <cstdio>
#include <algorithm>
using namespace std;
const int N=100;
double y[N*2];
struct Line
{
    int co;
    double x,y1,y2;
    void fun(double a,double b,double c,int d){x=a;y1=b;y2=c;co=d;}
}line[N*2];
struct node
{
    int left,right,co;
    double rf,lf,len;
    int mid(){return left+(right-left)/2;}
    void change(int a)
    {
        co+=a;
        if(co==0){len=0;}
        else len=rf-lf;
    }
};
struct Segtree
{
    node tree[N*8];
    void build(int left,int right,int r)
    {
        tree[r].left=left;  tree[r].right=right;
        tree[r].lf=y[left]; tree[r].rf=y[right];
        tree[r].len=0;
        if(left+1<right)
        {
            int mid=tree[r].mid();
            build(left,mid,r*2);
            build(mid,right,r*2+1);
        }
    }
    void updata(Line e,int r)
    {
        if(tree[r].left+1==tree[r].right)
        {
            tree[r].change(e.co);
        }
        else
        {
            if(e.y1<tree[r*2].rf) updata(e,r*2);
            if(e.y2>tree[r*2+1].lf) updata(e,r*2+1);
            tree[r].len=tree[r*2].len+tree[r*2+1].len;
        }
    }
}seg;
int deal(int);
bool cmp(const Line &e1,const Line &e2)
{
    return e1.x<e2.x;
}
int main()
{
    int n,t_cnt=0;
    while(scanf("%d",&n)!=EOF)
    {
        if(n==0) break;

        int d=0;
        double x1,y1,x2,y2,ans=0;
        for(int i=0;i<n;i++)
        {
            scanf("%lf%lf%lf%lf",&x1,&y1,&x2,&y2);
            line[d].fun(x1,y1,y2,1);    y[d++]=y1;
            line[d].fun(x2,y1,y2,-1);   y[d++]=y2;
        }

        int cnt=deal(d);
        seg.build(0,cnt-1,1);
        seg.updata(line[0],1);
        for(int i=1;i<d;i++)
        {
            ans+=((line[i].x-line[i-1].x)*seg.tree[1].len);
            seg.updata(line[i],1);
        }
        printf("Test case #%d\nTotal explored area: %.2f\n\n",++t_cnt,ans);
        //POJ上%.2lf过不了。。。
    }
    return 0;
}
int deal(int n)
{
    sort(y,y+n);
    sort(line,line+n,cmp);

    int cnt=1;
    for(int i=1;i<n;i++)
    {
        if(y[i]!=y[i-1]) y[cnt++]=y[i];
    }
    return cnt;
}