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

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

回忆一下一般的求矩形覆盖面积，线段树节点里面有一个重要的变量，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  , 即直接将左右孩子给覆盖了两次或以上的长度加起来，这样才能做到不重不漏

转自：http://www.cnblogs.com/scau20110726/archive/2013/04/14/3020998.html

#include <cstdio>
#include <cstring>
#include <cctype>
#include <algorithm>
using namespace std;
#define lson l , m , rt << 1
#define rson m + 1 , r , rt << 1 | 1

const int maxn = 2222;
int cnt[maxn << 2];//边重复的次数
double sum[maxn << 2];//1次及以上
double sum2[maxn << 2];//2次及以上
double X[maxn];
struct Seg {
	double h, l, r;
	int s;//1为入边，-1为出边
	Seg() {}
	Seg(double a, double b, double c, int d) : l(a), r(b), h(c), s(d) {}
	bool operator < (const Seg &cmp) const {
		return h < cmp.h;
	}
}ss[maxn];
void PushUp(int rt, int l, int r) {
	
	if (cnt[rt]) { sum[rt] = X[r + 1] - X[l]; }//表示被完全覆盖，覆盖长度就是该区间长度
	else if (l == r) sum[rt] = 0;//因为是叶子没有孩子了，所以被覆盖两次货以上的长度就是0
	else sum[rt] = sum[rt << 1] + sum[rt << 1 | 1]; //没有被完全覆盖（但不代表没有被覆盖）
	//覆盖两次及以上
	if (cnt[rt]>1) { sum2[rt] = X[r + 1] - X[l]; }//表示被完全覆盖，覆盖长度就是该区间长度
	else if (l == r) sum2[rt] = 0;
	else if(cnt[rt]==1)sum2[rt]= sum[rt << 1] + sum[rt << 1 | 1];//不是叶子节点 ，且cnt=1.
	//这个区间被完全覆盖了1次，而有没有被完全覆盖两次或以上则不知道无法确定
	//左右孩子区间被覆盖了一次或以上的长度，那么叠加在双亲上就是双亲被覆盖两次或以上的长度
	else sum2[rt] = sum2[rt << 1] + sum2[rt << 1 | 1]; //不是叶子节点，且cnt = 0，
	//不知道有没有被覆盖，被覆盖了几次，长度是多少都不知道，这种情况，只能由其左右孩子的信息所得
	//直接将左右孩子给覆盖了两次或以上的长度加起来，这样才能做到不重不漏
}
void update(int L, int R, int c, int l, int r, int rt) {
	if (L <= l && r <= R) {
		cnt[rt] += c;
		PushUp(rt, l, r);
		return;
	}
	int m = (l + r) >> 1;
	if (L <= m) update(L, R, c, lson);
	if (m < R) update(L, R, c, rson);
	PushUp(rt, l, r);
}
int Bin(double key, int n, double X[]) {//二分查找位置
	int l = 0, r = n - 1;
	while (l <= r) {
		int m = (l + r) >> 1;
		if (X[m] == key) return m;
		if (X[m] < key) l = m + 1;
		else r = m - 1;
	}
	return -1;
}
int main() {
	int t;
	scanf("%d", &t);
	while (t--)
	{
		int n;
		scanf("%d", &n);
			int m = 0;
			while (n--) {
				double a, b, c, d;
				scanf("%lf%lf%lf%lf", &a, &b, &c, &d);
				X[m] = a;
				ss[m++] = Seg(a, c, b, 1);
				X[m] = c;
				ss[m++] = Seg(a, c, d, -1);
			}
			//离散化
			sort(X, X + m);
			sort(ss, ss + m);
			int k = 1;
			for (int i = 1; i < m; i++) {//去重
				if (X[i] != X[i - 1]) X[k++] = X[i];
			}
			memset(cnt, 0, sizeof(cnt));
			memset(sum, 0, sizeof(sum));
			double ret = 0;
			for (int i = 0; i < m - 1; i++) {
				int l = Bin(ss[i].l, k, X);
				int r = Bin(ss[i].r, k, X) - 1;
				if (l <= r) update(l, r, ss[i].s, 0, k - 1, 1);
				ret += sum2[1] * (ss[i + 1].h - ss[i].h);//sum[1]代表x轴的长度和
			}
			printf("%.2lf\n",  ret);
		}
	return 0;
}