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

 

#include <cstdio>

#include <cstring>

#include <algorithm>

using namespace std;

#define N 1010

#define lch(i) ((i)<<1)

#define rch(i) ((i)<<1|1)



double pos[2*N];

struct segment

{

    double l,r,h;

    int v;

}s[2*N];

struct node

{

    int l,r,cnt;

    double s,ss;

    int mid()

    { return (l+r)>>1; }

}t[2*N*4];

int n;



int cmp(struct segment p ,struct segment q)

{

    return p.h<q.h;

}



void build(int l ,int r ,int rt)

{

    t[rt].l=l; t[rt].r=r;

    t[rt].cnt=t[rt].s=t[rt].ss=0;

    if(l==r) return ;

    int mid=t[rt].mid();

    build(l,mid,lch(rt));

    build(mid+1,r,rch(rt));

}



int binarysearch(double key ,int low ,int high)

{

    while(low <= high)

    {

        int mid=(low+high)>>1;

        if(pos[mid] == key) 

            return mid;

        else if(pos[mid] < key) 

            low=mid+1;

        else

            high=mid-1;

    }

    return -1;

}



void cal(int rt)

{

    if(t[rt].cnt)

        t[rt].s = pos[t[rt].r+1] - pos[t[rt].l];

    else if(t[rt].l == t[rt].r)

        t[rt].s=0;

    else 

        t[rt].s = t[lch(rt)].s + t[rch(rt)].s;

/**************************************************/

    if(t[rt].cnt > 1)

        t[rt].ss = pos[t[rt].r+1] - pos[t[rt].l];

    else if(t[rt].l == t[rt].r)

        t[rt].ss = 0;

    else if(t[rt].cnt == 1)

        t[rt].ss = t[lch(rt)].s + t[rch(rt)].s;

    else

        t[rt].ss = t[lch(rt)].ss + t[rch(rt)].ss;

}



void updata(int l , int r ,int v ,int rt)

{

    if(t[rt].l==l && t[rt].r==r)

    {

        t[rt].cnt += v;

        cal(rt);

        return ;

    }

    int mid=t[rt].mid();

    if(r<=mid)     updata(l,r,v,lch(rt));

    else if(l>mid) updata(l,r,v,rch(rt));

    else

    {

        updata(l,mid,v,lch(rt));

        updata(mid+1,r,v,rch(rt));

    }

    cal(rt);

}



int main()

{

    int T;

    scanf("%d",&T);

    while(T--)

    {

        scanf("%d",&n);

        int i,k;

        for(i=0,k=0; i<n; i++,k+=2)

        {

            double x1,y1,x2,y2;

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

            pos[k]=x1; pos[k+1]=x2;

            s[k].l=x1;   s[k].r=x2;   s[k].h=y1;   s[k].v=1;

            s[k+1].l=x1; s[k+1].r=x2; s[k+1].h=y2; s[k+1].v=-1;

        }

        sort(pos,pos+k);

        sort(s,s+k,cmp);

        int m=1;

        for(i=1; i<k; i++)

            if(pos[i]!=pos[i-1])

                pos[m++]=pos[i];



        build(0,m-1,1);

        double res=0;

        for(i=0; i<k-1; i++)

        {

            int l=binarysearch(s[i].l,0,m-1);

            int r=binarysearch(s[i].r,0,m-1)-1;

            updata(l,r,s[i].v,1);

            res += t[1].ss*(s[i+1].h - s[i].h);

        }

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

    }

    return 0;

}