HDU 1255 覆盖的面积

/*
做这题的时候是参考别人的程序
现在拿出来回顾下
好好理解一下这题的思路
第一，这题需要离散化
第二,计算矩形并的面积 当某一条线段被覆盖两次或两次以上 计算一次面积 具体的画个图比较明了
第三，也是最重要的，线段数once, more的更新， 当时没有掌握到线段数的精髓 也是迷迷糊糊的，
现在回来想想，once more 是第一类信息 表示当前区间的性质
所有递归回来的时候 由递推关系更新once more 而more 又是由once 推出来的 
*/
#include <stdio.h>

#include <stdlib.h>

#include <math.h>

#define EPS 1e-8

#define L(x) ((x) << 1)

#define R(x) ((x) << 1 | 1)



const int MAXN = 2222;

struct Line

{

	double x,y1,y2;

	int flag;

};

bool equal(double a, double b){

	if( fabs(a - b) <= EPS)

		return true;

	return false;

}

int doubleCmp(const void *a, const void *b){

	return *(double*)a - *(double*)b > 0 ? 1 : -1;

}

int cmp(const void *a, const void *b){

	Line *l1 = (Line*)a;

	Line *l2 = (Line*)b;

	if( equal(l1 -> x, l2 -> x)){

		return l1 -> flag - l2 -> flag;

	}

	return (l1 -> x) - (l2 -> x) > 0 ? 1 : -1;	//浮点数比较大小 要注意

}



struct segTree

{

	int l,r;	

	int cov;		//覆盖次数

	double once, more;	//覆盖一次的长度和覆盖两次的长度

};



Line line[2 * MAXN];

segTree tree[MAXN * 4];		//空间

double pointy[2 * MAXN];



void bulid(int left, int right, int t){

	tree[t].l = left;

	tree[t].r = right;

	tree[t].cov = 0;

	tree[t].once = tree[t].more = 0.0;

	tree[L(t)].cov = 0;

	tree[L(t)].once = tree[L(t)].more = 0.0;

	tree[R(t)].cov = 0;

	tree[R(t)].once = tree[R(t)].more = 0.0;

	if( right - left == 1)

		return;

	int mid = (left + right) >> 1;

	

	bulid(left, mid, L(t));

	bulid(mid, right, R(t));

}





int bsearch(int l, int r, double temp){

	

	while(l <= r){

		int mid = ( l + r ) >> 1; 

		if( equal(pointy[mid], temp)){

			return mid;

		} else if( pointy[mid] > temp ){

			r = mid - 1;

		} else if(pointy[mid] < temp){

			l = mid + 1;

		}

	}

	return -1;

}

void rr(int t,int l, int r){
	//分情况讨论

	if(tree[t].cov > 1){	//覆盖多次

		tree[t].once = 0;

		tree[t].more = pointy[r] - pointy[l];

	} else if( tree[t].cov == 1){	//覆盖一次 则覆盖两次的长度为儿子覆盖一次和两次的长度之和 覆盖一次的长度则为总长度减去覆盖多次的长度 因为不可能存在没被覆盖的区域

		tree[t].more = tree[L(t)].more + tree[R(t)].more 

			+ tree[L(t)].once + tree[R(t)].once;

		tree[t].once = pointy[r] - pointy[l] - tree[t].more;

	} else {	// == 0 没被覆盖

		if( r - l == 1){			//叶子

			tree[t].once = tree[t].more = 0;

		} else {				//由左右孩子的once more 更新自己的once more

			tree[t].once = tree[L(t)].once + tree[R(t)].once;

			tree[t].more = tree[L(t)].more + tree[R(t)].more;

		}

	}

}



void update(int l, int r, int t, int flag){
	/*这递归不是我的风格 哈哈 真是copy啊*/

	if( l >= tree[t].r || r <= tree[t].l)	//不在这个区间 

		return;

	if( l <= tree[t].l && r >= tree[t].r){ 	//包含这个区间

		tree[t].cov += flag;

		rr(t,tree[t].l,tree[t].r);	//如果覆盖区间 则rr once more 然后直接返回 

		return; 			//important	

	}

	update(l, r, L(t), flag);

	update(l, r, R(t), flag);

	rr(t,tree[t].l,tree[t].r);		//rr函数更新节点的once more

}





int main(){

	int t, n, i, j;

	double x1, x2, y1, y2;

	scanf("%d",&t);

	while( t-- ){

		scanf("%d",&n);

		j = 1;

		for(i = 1; i <= n; i++){

			scanf("%lf%lf%lf%lf",&x1, &y1, &x2, &y2);

			line[j].x = x1;

			line[j].y1 = y1;

			line[j].y2 = y2;

			line[j].flag = 1;

			pointy[j] = y1;

			j++;

			line[j].x = x2;

			line[j].y1 = y1;

			line[j].y2 = y2;

			line[j].flag = -1;

			pointy[j] = y2;

			j++;

		}

		qsort(pointy + 1, 2 * n , sizeof(pointy[0]), doubleCmp);

		qsort(line + 1, 2 * n , sizeof(line[0]), cmp);

		//离散化

		int size = 1;

		for(i = 2; i <= 2 * n; i++){

			if(!equal(pointy[i] , pointy[i - 1])){

				pointy[++size] = pointy[i];

			}

		}

		bulid(1, size, 1);

		double ans = 0.0;

		for(i = 1; i <= 2 * n; i++){

			if(i != 1){

				ans += (line[i].x - line[i - 1].x) * tree[1].more;

			}

			int y1 = bsearch(1, size, line[i].y1);

			int y2 = bsearch(1, size, line[i].y2);

			update(y1, y2, 1, line[i].flag);

		}

		printf("%.2lf\n",ans);

	}

	return 0;

}