求覆盖后的面积---线段树+扫描线+离散化

 http://acm.hdu.edu.cn/showproblem.php?pid=1542

题意:

二维平面有n个平行于坐标轴的矩形,现在要求出这些矩形的总面积. 重叠部分只能算一次.

分析:

线段树的典型扫描线用法.

       首先假设有下图两个矩阵,我们如果用扫描线的方法如何计算它们的总面积呢?

又因为上面2个矩形有4个不同的浮点数x坐标,所以我们需要把x坐标离散化,这样才能用线段树来维护信息.所以我们这样离散化:

由上图可知,4个不同的x坐标把x轴分成了3段有效的区间.这里要注意我们线段树中每个叶节点(控制区间[L,L])不是指X[L]坐标,而是指区间[X[L],X[L+1]].线段树中其他节点控制的区间[L,R],也是指的x坐标轴的第L个区间到第R个区间的范围,也就是X[L]到X[R+1]坐标的范围.

然后我们Y坐标从小到大的顺序读入每条扫描线,并维护当前我们所读入的所有扫描线能有效覆盖X轴的最大长度sum[1].这里特别要注意如果我们读入的扫描线是矩形的下位边,那么我们就使得该范围的标记cnt位+1,如果是上位边,那么该范围的cnt就-1.所以如果cnt=0时,表示该节点控制的范围没有被覆盖,只要cnt!=0 就表示该节点控制的几块区间仍然被覆盖.

下面依次读入每条矩阵边,来一一分析,首先是读入第一条矩阵边:

我们读入了矩形1的下位边,那么该区域的cnt就+1=1了,所以该区域[10,20]就被覆盖了,然后可以推出整个区域被覆盖的长度是10.再根据第二条扫描线离第一条扫描线的高度差为5.所以不管你第二条扫描线是哪个矩形的什么边,或者能覆盖到X轴的什么范围,我上图中蓝色的矩形面积肯定是要算到总面积里面去的.即总面积ret+=sum[1]*(扫描线2的高度-扫描线1的高度). (想想看是不是这样).

下面读第二条扫描线:

由于第二条扫描线也是下位边,所以[15,20]和[20,25]的cnt+1.使得我们覆盖的范围变成了[10,25]了,并且第3条扫描线在20高度,所以这次我们必然增加的面积是上面深蓝色的长条=sum[1]*(扫描线3的高度-扫描线2的高度).

下面我们要读第三条扫描线了:

由于第三条扫描线是区间[10,20]的上位边,所以对应区间的cnt要-1,所以使得区间[10,15]的cnt=0了,而[15,20]区间的cnt-1之后变成了1.[20,25]的cnt仍然为1,不变.所以当前覆盖的有效x轴长度为10,即区间[15,25].所以增加的面积是图中褐色的部分.

到此,矩形的面积和就算出来了.由于对于任一矩形都是先读下位边(cnt+1),再读上位边(cnt-1)的,所以在更新线段树的过程中,任意节点的cnt都是>=0的.

下面说代码实现部分:

首先建立一个node结构体用来保存每条扫描线,node中有信息:

l: 表示扫描线的左端x坐标

r:表示扫描线的右端x坐标

h: 表示扫描线的高度

d: 为1或-1,标记扫描线是矩形的上位还是下位边.

我们首先读入所有矩形的信息,每读入一个矩形信息我们就更新两条扫描线,并且把矩形的两个端点x坐标放入X[MAXN]数组中,

然后我们对node和X都排序,node按h值从小到大排序.

X按从小到大排序.

然后我们在X的本地数组内,对X去重,并且用k表示一共有多少个X.

当我们需要找到第i个区域的两端点坐标时,只需要X[i]和X]i+1].

 本人代码：

#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[3000];
//线段树节点 
struct node{
	//在[x[l],x[r+1]]的区间内下位边的个数与上位边的个数差 
    ll l,r,mark;
    //底边长sum 
    double sum;
}a[3000];
//离散化数组 
double x[3000];//不要开成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=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){
    	//如果此段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;
    }
}
//修改整个线段树的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 n,Case=0;
    while(cin>>n&&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);//建树，注意叶节点为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].sum*(line[i+1].h-line[i].h);
        }
        printf("Test case #%d\nTotal explored area: %.2f\n\n",++Case,ans);
    }
    
    return 0;
}

 

别人代码：

#include<stdio.h>
#include<string>
#include<algorithm>
#include<iostream>
using namespace std;
const int MAX=210;
int N;
double x[MAX<<2];
struct Node
{
    double l, r;
    double h;
    int flag;
}node[MAX<<2];
int cmp(Node a, Node b)
{
    return a.h<b.h;
}
struct Tree
{
    int l, r;
    int cnt;
    double len;
}tree[MAX<<2];
int findPos(int l, int r, double val)
{
    int mid;
    while(l<=r)
    {
        mid=(l+r)>>1;
        if(x[mid]>val)
            r=mid-1;
        else if(x[mid]<val)
            l=mid+1;
        else
            break;
    }
    return mid;
}
void build(int rt, int left, int right)
{
    tree[rt].l=left;
    tree[rt].r=right;
    tree[rt].len=0;
    tree[rt].cnt=0;
    if(left==right)
        return ;
    int mid=(left+right)>>1;
    build(rt<<1, left, mid);
    build(rt<<1|1, mid+1, right);
}
void pushUp(int rt)
{
    if(tree[rt].cnt)//非0，整段覆盖
        tree[rt].len=x[tree[rt].r+1]-x[tree[rt].l];
    else if(tree[rt].l==tree[rt].r)//叶子
        tree[rt].len=0;
    else//部分覆盖
        tree[rt].len=tree[rt<<1].len+tree[rt<<1|1].len;
}
void update(int rt, int left, int right, int val)
{
    if(left<=tree[rt].l && tree[rt].r<=right)//全部包含
    {
        tree[rt].cnt+=val;
        pushUp(rt);
        return ;
    }
    int mid=(tree[rt].l+tree[rt].r)>>1;
    if(left<=mid)
        update(rt<<1, left, right, val);
    if(right>mid)
        update(rt<<1|1, left, right, val);
    pushUp(rt);//计算该区间被覆盖的总长度
}
int main()
{
    int K=0;
    int l, r;
    double x1, x2, y1, y2;
    while(~scanf("%d", &N), N)
    {
        int cnt=0;
        for(int i=1; i<=N; i++)
        {
            scanf("%lf%lf%lf%lf", &x1, &y1, &x2, &y2);
            x[++cnt]=x1;
            node[cnt].l=x1;
            node[cnt].r=x2;
            node[cnt].h=y1;
            node[cnt].flag=1;//下边
            x[++cnt]=x2;
            node[cnt].l=x1;
            node[cnt].r=x2;
            node[cnt].h=y2;
            node[cnt].flag=-1;//上边
        }
        sort(x+1, x+cnt+1);//排序
        sort(node+1, node+cnt+1, cmp);
        /*
        int M=1;
        for(int i=1; i<cnt; i++)//去重  可去可不去
            if(x[i]!=x[i-1])
                x[M++]=x[i];
        */
        build(1, 1, cnt);
        double ans=0;
        for(int i=1; i<=cnt; i++)//拿出每条横线并且更新
        {
            l=findPos(1, cnt, node[i].l);
            r=findPos(1, cnt, node[i].r)-1;
            update(1, l, r, node[i].flag);
            ans+=tree[1].len*(node[i+1].h-node[i].h);//求面积
        }
        printf("Test case #%d\nTotal explored area: %.2f\n\n", ++K, ans);
    }
    return 0;
}