求覆盖两次或以上的面积---线段树+扫描线+离散化

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

 

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  , 即直接将左右孩子给覆盖了两次或以上的长度加起来，这样才能做到不重不漏

 

#include<stdio.h>
#include<iostream>
#include<algorithm>
#include<string.h>
#include<vector>
#include<cmath>
#include<string>
#include<map>
#include<queue>
using namespace std;
typedef long long ll;
//存储扫描线
//扫描线的左右端点，纵坐标和区分上位边、下位边的标记 
struct seg{
    double l,r,h;
    ll flag;
    //快速赋值 
    seg() {}
    seg(double l,double r,double h,ll flag):l(l),r(r),h(h),flag(flag) {}
    //扫描线从低到高排序 
	bool operator < (const seg &k)const
    {
        return h<k.h;
    }
}line[4000];
//线段树节点 
struct node{
	//在[x[l],x[r+1]]的区间内下位边的个数与上位边的个数差 
    ll l,r,mark;
    //底边长sum 
    double sum,dsum;
}a[4000];
//离散化数组 
double x[4000];//不要开成long long 型 
//build the xianduanshu
void build(ll k,ll l,ll r){
    a[k].l=l;a[k].mark=0;
    a[k].r=r;a[k].sum=a[k].dsum=0;
    if(l==r)return ;
    ll mid=(a[k].l+a[k].r)>>1;
    build(k<<1,l,mid);
    build(k<<1|1,mid+1,r);
}
//
void update(ll k){
    if(a[k].mark){
    	a[k].sum=x[a[k].r+1]-x[a[k].l];
	}
	else if(a[k].l==a[k].r){
		a[k].sum=0;
	}
	else {
		a[k].sum=a[k<<1].sum+a[k<<1|1].sum;
	}
	
	if(a[k].mark>1){
		a[k].dsum=x[a[k].r+1]-x[a[k].l];
	}
	else if(a[k].l==a[k].r){
		a[k].dsum=0;
	}
	else if(a[k].mark==1){
		a[k].dsum=a[k<<1].sum+a[k<<1|1].sum;
	}
	else{
		a[k].dsum=a[k<<1].dsum+a[k<<1|1].dsum;
	}
}
//修改整个线段树的sum 
void change(ll k,ll l,ll r,ll flag){
    if(a[k].l>=l&&a[k].r<=r){//递归到所限制区间 
        a[k].mark+=flag;//上位边，-1；下位边，+1； 
        update(k);//更新此段底边长 
        return ;
    }
    ll mid=(a[k].l+a[k].r)>>1;
    if(l<=mid)change(k<<1,l,r,flag);
    if(r>mid)change(k<<1|1,l,r,flag);
    update(k);//更新知道全部更新 
}
 
int main(){
    ll t,n;
    cin>>t;
    while(t--){
    	cin>>n;
        double x1,x2,y1,y2;
        ll cnt1=0;
        ll cnt2=0;
        for(ll i=1;i<=n;i++){
			cin>>x1>>y1>>x2>>y2;
			//存横坐标 
			//离散化 
            x[++cnt1]=x1;
            x[++cnt1]=x2;
            //存扫描线信息 
            line[++cnt2]=seg(x1,x2,y1,1);
            line[++cnt2]=seg(x1,x2,y2,-1);
        }
        sort(x+1,x+1+cnt1);//排序 
        sort(line+1,line+1+cnt2);
        ll k=unique(x+1,x+cnt1+1)-x-1;//去重 
        build(1,1,k-1);//建树，注意叶节点为k个 
        double ans=0.0;
        for(ll i=1;i<cnt2;i++){
        	//寻找第i个扫描线的左右端点对应的区间 
            ll l=lower_bound(x+1,x+1+k,line[i].l)-x;
            ll r=lower_bound(x+1,x+1+k,line[i].r)-x;
            r--;
            //修改该区间的底边长 
            change(1,l,r,line[i].flag);
            //底乘高 
            ans+=a[1].dsum*(line[i+1].h-line[i].h);
        }
        printf("%.2f\n",ans);
    }
    
    return 0;
}