覆盖的面积 HDU - 1255（线段树+扫描线求二次重叠面积）

覆盖的面积

HDU - 1255

给定平面上若干矩形,求出被这些矩形覆盖过至少两次的区域的面积.

 

Input

输入数据的第一行是一个正整数T(1<=T<=100),代表测试数据的数量.每个测试数据的第一行是一个正整数N(1<=N<=1000),代表矩形的数量,然后是N行数据,每一行包含四个浮点数,代表平面上的一个矩形的左上角坐标和右下角坐标,矩形的上下边和X轴平行,左右边和Y轴平行.坐标的范围从0到100000.

注意:本题的输入数据较多,推荐使用scanf读入数据.

Output

对于每组测试数据,请计算出被这些矩形覆盖过至少两次的区域的面积.结果保留两位小数.

Sample Input

2
5
1 1 4 2
1 3 3 7
2 1.5 5 4.5
3.5 1.25 7.5 4
6 3 10 7
3
0 0 1 1
1 0 2 1
2 0 3 1

Sample Output

7.63
0.00

题意中文，不解释

这题的代码在一般的线段树求面积并的基础上进行了修改，但是所用的思想是一样的，所以不难理解

回忆一下一般的求矩形覆盖面积，线段树节点里面有一个重要的变量，cnt。这个变量表示了该节点表示的区间被完全覆盖，如果cnt=0，说明没有被完全覆盖（但不代表没有被覆盖），要算出该节点所代表的区间被覆盖的长度，需要由它左右孩子节点被覆盖的长度相加所得。如果cnt=1，表示被完全覆盖，覆盖长度就是该区间长度。如果cnt>1说明也是被完全覆盖，不过不止覆盖了一次，在算覆盖长度的时候，和cnt=1的计算方法是一样的。注意一点，节点里还有另一个变量len，就是该区间被覆盖的长度，但是我们注意一下，这个len准确的意义应该是，被覆盖了一次或以上的长度，只是这个意义在一般的求面积问题中，不需要过分强调

 

而在这题中我们要计算被覆盖两次或以上的部分面积，我们在线段树节点中增设了一个变量，ss，其中s表示该该区间内被覆盖了1次或以上的长度，ss表示被覆盖了2次或以上的长度

我们是怎么计算最后的面积的？一样的道理，从下往上扫描矩形，每次添加一条矩形上下边，然后看看t[1].ss是多少，再乘上高度差。因为t[1]表示了总区间，而ss表示被覆盖两次或以上的长度，即计算时我们忽略掉只被覆盖一次的长度

问题的关键变为怎么计算一个节点的ss

分情况讨论

1.cnt>1 : 说明该区间被覆盖两次或以上，那么长度就可以直接计算，就是该区间的长度

剩下的情况就是cnt=1或cnt=0

2.先看叶子节点，因为是叶子没有孩子了，所以被覆盖两次货以上的长度就是0（无论cnt=1或cnt=0都是0，因为是叶子。。。）

3.不是叶子节点 ，且cnt=1.注意这里，cnt=1确切的意义是什么，应该是，可以确定，这个区间被完全覆盖了1次，而有没有被完全覆盖两次或以上则不知道无法确定，那么怎么怎么办了，只要加上t[lch].s + t[rch].s  即，看看左右孩子区间被覆盖了一次或以上的长度，那么叠加在双亲上就是双亲被覆盖两次或以上的长度

3.不是叶子节点，且cnt=0，确切的意义应该是不完全不知道被覆盖的情况（不知道有没有被覆盖，被覆盖了几次，长度是多少都不知道），这种情况，只能由其左右孩子的信息所得

t[lch].ss + t[rch].ss  , 即直接将左右孩子给覆盖了两次或以上的长度加起来，这样才能做到不重不漏

注意！！始终是下边为1，上边-1，因为只有这样，标记覆盖次数cnt才能是正的，题目题意有问题和输入样例不符，按照输入样例为准

code：

#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <cmath>
using namespace std;
#define ls i<<1
#define rs i<<1|1
#define m(i) ((q[i].l+q[i].r)>>1)
typedef long long ll;
const int N = 1004;
struct Edge{//扫描线
	double l,r;
	double h;
	int f;
	bool operator < (const Edge &a)const{
		return h < a.h;
	}
}e[N<<1];
struct Node{
	int l,r;
	int s;//该区间到覆盖状态
	double len1;//覆盖1次及以上的长度
	double len2;//覆盖2次及以上的长度
}q[(2*N)<<2];
double x[N<<1];
void pushup(int i){
	if(q[i].s){
		q[i].len1 = x[q[i].r+1] - x[q[i].l];
	}
	else if(q[i].l == q[i].r){
		q[i].len1 = 0;
	}
	else{
		q[i].len1 = q[ls].len1 + q[rs].len1;
	}
	//下面是不同于1次覆盖的部分
	if(q[i].s > 1){//该区间完全覆盖2次及以上
		q[i].len2 = x[q[i].r+1] - x[q[i].l];
	}
	else if(q[i].l == q[i].r){
		q[i].len2 = 0;
	}
	else if(q[i].s == 1){
		//这里可能需要理解一下，s=1说明这个区间要被
		//完整覆盖，但是之前子区间已经有的被覆盖了1次
		//这个时候我们只需要找这个区间左右子区间覆盖1次的就行了，加上这次完全覆盖就是2次了
		q[i].len2 = q[ls].len1 + q[rs].len1;
	}
	else{
		//如果覆盖0次那么只能去子区间内找覆盖两次的了
		q[i].len2 = q[ls].len2 + q[rs].len2;
	}
}
void build(int i,int l,int r){
	q[i].l = l;
	q[i].r = r;
	q[i].s = q[i].len1 = q[i].len2 = 0;
	if(l == r) return;
	int mid = m(i);
	build(ls,l,mid);
	build(rs,mid+1,r);
}
void update(int i,int l,int r,int f){
	if(l == q[i].l && q[i].r == r){
		q[i].s += f;
		pushup(i);
		return;
	}
	int mid = m(i);
	if(r <= mid) update(ls,l,r,f);
	else if(l > mid) update(rs,l,r,f);
	else{
		update(ls,l,mid,f);
		update(rs,mid+1,r,f);
	}
	pushup(i);
}
int main(){
	int T;
	scanf("%d",&T);
	while(T--){
		int n;
		scanf("%d",&n);
		int tot = 0;
		double x1,x2,y1,y2;
		for(int i = 1; i <= n; i++){
			scanf("%lf%lf%lf%lf",&x1,&y1,&x2,&y2);
			Edge &t1 = e[tot];
			Edge &t2 = e[tot+1];
			t1.l = t2.l = x1;
			t1.r = t2.r = x2;
			t1.h = y1;
			t1.f = 1;
			t2.h = y2;
			t2.f = -1;
			x[tot] = x1;
			x[tot+1] = x2;
			tot += 2;
		}
		sort(x,x+tot);
		sort(e,e+tot);
		int k = 1;
		for(int i = 1; i < tot; i++){
			if(x[i] != x[i-1])
				x[k++] = x[i];
		}
		build(1,0,k-1);
		double ans = 0.0;
		for(int i = 0; i < tot; i++){
			int l = lower_bound(x,x+k,e[i].l) - x;
			int r = lower_bound(x,x+k,e[i].r) - x -1;
			update(1,l,r,e[i].f);
			ans += q[1].len2 * (e[i+1].h - e[i].h);
		}
		printf("%.2f\n",ans);
	}
	return 0;
}