hdu 1255 覆盖的面积（扫描线）

题意：有T组测试数据，每组数据先给一个数字N，接下来的N行里，每行四个浮点数表示矩形的左上角坐标和右下角坐标，要求这些矩形至少覆盖过两次的面积。

        与POJ 1151 Atlantis 的差别是，我们在答案里加上的不是覆盖一次的长度乘以两条线之间x坐标的差，而是用覆盖两次的长度，那么问题就变成如果从覆盖一次的面积得到覆盖两次的面积。

        为叙述方便，我们假设len[2]为当前线段被覆盖了两次的长度，len[1]为当前线段被覆盖了一次的长度，而len[0]就是这条线段的长度，并且满足len[2]+len[1]=len[0]。

        首先，如果当前这条线段已经被覆盖了两次了，那么这条线段的len[2]就应该等于len[0]，而len[1]就应该等于0。

        其次，如果当前这条线段被覆盖了一次，那么这条线段的len[2]就应该是，左右子线段的len[2]的和加上左右子线段的len[1]，当然，前提是当前线段不能是线段树中的叶子结点，否则它就没有左右子线段不是吗？这时候，当前线段的len[2]就应该等于0。而len[1]就等于len[0]，最后要注意当前线段的len[1]要减去len[2]，以满足len[1]+len[2]=len[0]。

        最后，如果这条线段没有被覆盖过，并且当前线段不是线段树里的叶子结点，那么它的len[1]和len[2]都应该从它的左右子线段的len[1]和len[2]得到，如果是叶子结点，那么len[1]和len[2]都等于0。

#include <iostream>
#include <cstdio>
#include <cstring>
#include <vector>
#include <map>
#include <algorithm>
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=2000;

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 len[3];
	int mid(){return MID(lft,rht);}
	void init(){memset(len,0,sizeof(len));}
};

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

struct Segtree
{
	node tree[N*4];
	void calu_len(int ind)
	{
		if(tree[ind].flag>=2)
		{
			tree[ind].len[2]=tree[ind].len[0];
			tree[ind].len[1]=0;
		}
		else if(tree[ind].flag==1)
		{
			if(tree[ind].lft+1==tree[ind].rht) tree[ind].len[2]=0;
			else tree[ind].len[2]=tree[LL(ind)].len[2]+tree[RR(ind)].len[2]
                +tree[LL(ind)].len[1]+tree[RR(ind)].len[1];
			tree[ind].len[1]=tree[ind].len[0];
			tree[ind].len[1]-=tree[ind].len[2];
		}
		else
		{
			if(tree[ind].lft+1==tree[ind].rht)
				tree[ind].len[1]=tree[ind].len[2]=0;
			else
			{
				tree[ind].len[2]=tree[LL(ind)].len[2]+tree[RR(ind)].len[2];
				tree[ind].len[1]=tree[LL(ind)].len[1]+tree[RR(ind)].len[1];
			}
		}
	}
	void build(int lft,int rht,int ind)
	{
		tree[ind].lft=lft;	tree[ind].rht=rht;
		tree[ind].init();	tree[ind].flag=0;
		tree[ind].len[0]=y[rht]-y[lft];
		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(st<=lft&&rht<=ed) tree[ind].flag+=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);
		}
		calu_len(ind);
	}
}seg;
int main()
{
	int t;
	scanf("%d",&t);
	while(t--)
	{
		y.clear(); H.clear(); line.clear();

		scanf("%d",&n);

		double x1,y1,x2,y2;
		for(int i=0;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;
		for(int i=0;i<(int)line.size();i++)
		{
			if(i!=0) res+=(line[i].x-line[i-1].x)*seg.tree[1].len[2];
			seg.updata(H[line[i].y1],H[line[i].y2],1,line[i].flag);
		}
		printf("%.2lf\n",res);
	}
	return 0;
}