线段树+扫描线

转载自 https://blog.csdn.net/xianpingping/article/details/83032798

扫描线：

下面是来自soar转载的一篇博客。

横扫

这篇博客解决了我对算区间长度时的不理解。实际上这个线段树的叶子节点保存的是这个点x坐标到下一个x坐标（排序后的）的区间长度。

题意:

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

分析:

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

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

首先我们将矩形的上下边分为上位边(即y坐标大的那条平行于x轴的边),和下位边(y坐标小的平行于x轴的边).然后我们把所有矩形的上下位边按照他们y坐标从小到大排序,可以得到4条扫描线:

又因为上面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].

 

线段树维护cnt(根本信息)和sum两个信息,其中sum为double,cnt为int型.

cnt: >=0时表示本节点控制的区域内下位边个数-上位边个数的结果.如果==-1时,表示本节点左右子树的上下位边数不一致.

sum: 本节点控制的区域内cnt值不为0的区域总长度.

 

线段树操作:

PushDown(i,l,r):如果cnt!=-1,那么下放cnt信息,并更新子节点的sum信息.

PushUp(i,l,r): 根据子节点的cnt值和sum值更新父节点的cnt和sum值.

update(ql,qr,v,i,l,r): 使得[ql,qr]与[l,r]区间的公共部分cnt值+v.

如果ql<=l && r<=qr 且 cnt[i]!=-1的话,直接更新并return

否则先PushDown

在一次递归更新左右儿子

最后PushUp.
 

#include<iostream>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<string>
#include<queue>
#include<algorithm>
#include<map>
#include<iomanip>
#define INF 99999999
using namespace std;
 
const int MAX=200+10;
int mark[MAX<<2];//记录某个区间的下底边个数
double sum[MAX<<2];//记录某个区间的下底边总长度
double hash[MAX];//对x进行离散化,否则x为浮点数且很大无法进行线段树 
 
//以横坐标作为线段(区间),对横坐标线段进行扫描
//扫描的作用是每次更新下底边总长度和下底边个数,增加新面积 
struct seg{//线段 
	double l,r,h;
	int d;
	seg(){}
	seg(double x1,double x2,double H,int c):l(x1),r(x2),h(H),d(c){}
	bool operator<(const seg &a)const{
		return h<a.h;
	}
}s[MAX];
 
void Upfather(int n,int left,int right){
	if(mark[n])sum[n]=hash[right+1]-hash[left];//表示该区间整个线段长度可以作为底边 
	else if(left == right)sum[n]=0;//叶子结点则底边长度为0(区间内线段长度为0) 
	else sum[n]=sum[n<<1]+sum[n<<1|1];
}
 
void Update(int L,int R,int d,int n,int left,int right){
	if(L<=left && right<=R){//该区间是当前扫描线段的一部分,则该区间下底边总长以及上下底边个数差更新 
		mark[n]+=d;//更新底边相差差个数 
		Upfather(n,left,right);//更新底边长 
		return;
	}
	int mid=left+right>>1;
	if(L<=mid)Update(L,R,d,n<<1,left,mid);
	if(R>mid)Update(L,R,d,n<<1|1,mid+1,right);
	Upfather(n,left,right);
}
 
int search(double key,double* x,int n){
	int left=0,right=n-1;
	while(left<=right){
		int mid=left+right>>1;
		if(x[mid] == key)return mid;
		if(x[mid]>key)right=mid-1;
		else left=mid+1;
	}
	return -1;
}
 
int main(){
	int n,num=0;
	double x1,x2,y1,y2;
	while(cin>>n,n){
		int k=0;
		for(int i=0;i<n;++i){
			cin>>x1>>y1>>x2>>y2;
			hash[k]=x1;
			s[k++]=seg(x1,x2,y1,1);
			hash[k]=x2;
			s[k++]=seg(x1,x2,y2,-1);
		}
		sort(hash,hash+k);
		sort(s,s+k);
		int m=1;
		for(int i=1;i<k;++i)//去重复端点 
		    if(hash[i] != hash[i-1])hash[m++]=hash[i];
        double ans=0;
        //memset(mark,0,sizeof mark);
        //memset(sum,0,sizeof sum);如果下面是i<k-1则要初始化,因为如果对第k-1条线段扫描时会使得mark,sum为0才不用初始化的 
		for(int i=0;i<k;++i){//扫描线段 
			int L=search(s[i].l,hash,m);
			int R=search(s[i].r,hash,m)-1;
			Update(L,R,s[i].d,1,0,m-1);//扫描线段时更新底边长度和底边相差个数
			ans+=sum[1]*(s[i+1].h-s[i].h);//新增加面积 
		}
		printf("Test case #%d\nTotal explored area: %.2lf\n\n",++num,ans);
	}
	return 0;
}
/*
这里注意下扫描线段时r-1:int R=search(s[i].l,hash,m)-1;
计算底边长时r+1:if(mark[n])sum[n]=hash[right+1]-hash[left];
解释:假设现在有一个线段左端点是l=0,右端点是r=m-1
则我们去更新的时候,会算到sum[1]=hash[mid]-hash[left]+hash[right]-hash[mid+1]
这样的到的底边长sum是错误的,why?因为少算了mid~mid+1的距离,由于我们这利用了
离散化且区间表示线段,所以mid~mid+1之间是有长度的,比如hash[3]=1.2,hash[4]=5.6,mid=3
所以这里用r-1,r+1就很好理解了 
*/ 

无注释精简版：

#include<bits/stdc++.h>
 
using namespace std;
 
#define lson i<<1,l,m
#define rson i<<1|1,m+1,r
 
const int maxn=222;
 
double x[maxn];
struct node
{
    double l,r,h;//左右坐标，高度
    int d;//标记上位边还是下位边
    node() {}
    node(double l,double r,double h,int d):l(l),r(r),h(h),d(d) {}
    bool operator < (const node &a)const
    {
        return h<a.h;
    }
} line[maxn];
 
int cnt[maxn<<2];
double sum[maxn<<2];
 
void pushup(int i,int l,int r)
{
   if(cnt[i])
   {
       sum[i]=x[r+1]-x[l];
   }
   else
   {
       sum[i]=sum[i<<1]+sum[i<<1|1];
   }
}
 
 
 
void update(int ql,int qr,int v,int i,int l,int r)
{
    if(ql<=l && qr>=r)
    {
       cnt[i]+=v;
       pushup(i,l,r);
       return ;
    }
 
    int m=(l+r)>>1;
    if(ql<=m)update(ql,qr,v,lson);
    if(qr>m)update(ql,qr,v,rson);
    pushup(i,l,r);
}
 
 
int main()
{
    int q;
    int kase=0;
    while(cin>>q&&q)
    {
        memset(cnt,0,sizeof(cnt));//相当于build
        memset(sum,0,sizeof(sum));//相当于build
        int n=0,m=0;
        for(int i=1; i<=q; i++)
        {
            double x1,y1,x2,y2;
            scanf("%lf%lf%lf%lf",&x1,&y1,&x2,&y2);
            x[++n]=x1;
            x[++n]=x2;
            line[++m]=node(x1,x2,y1,1);
            line[++m]=node(x1,x2,y2,-1);
        }
 
        sort(x+1,x+1+n);
        sort(line+1,line+1+m);
        int k=1;
        /* for(int i=2;i<=n;i++)//去重
         {
             if(x[i]!=x[i-1])x[++k]=x[i];
         }*/
        k=unique(x+1,x+n+1)-x-1;//直接用STL中的unique函数。
 
        double ans=0.0;
        for(int i=1; i<m; i++)
        {
 
            int l=lower_bound(x+1,x+k+1,line[i].l)-x;
            int r=lower_bound(x+1,x+k+1,line[i].r)-x;
            r--;
            if(l<=r)update(l,r,line[i].d,1,1,k-1);
            ans+=sum[1]*(line[i+1].h-line[i].h);
        }
        printf("Test case #%d\nTotal explored area: %.2f\n\n",++kase,ans);
    }
}

竖扫

扫描线一般运用在图形上面，它和它的字面意思十分相似，就是一条线在整个图上扫来扫去，它一般被用来解决图形面积，周长等问题，以一道例题为例。给出n个正方形，这些正方形在平面直角坐标系中互相重叠摆放，但四条边都与坐标轴平行，例如下图所示。那么知道题目了，怎么运用呢？首先我们需要知道怎么用暴力解决这个问题，根据图片可知图中的面积是SABCD+SHEFG-SIDJE暴力搜索是个好东西，但是当数据范围大了怎么办？这里就要讲到扫描线。

　　扫描线对于这道例题可以抽象为这四条紫色的直线（如上图l1，l2，l3，l4），仔细观察，可以看出这四条线把这个图形分割成三个矩形，那么我们就可以直接求这三个矩形再加和是不是就可以了？那么现在难点来了，怎样求这些矩形的面积。我们可以把题目中给的矩形的边转换成直线（如下图），即只留下这四条边，这四条线就是整个做法的核心。既然四条线已经看出来了，那么我们就可以一眼看出，面积就是从头到现在的扫描线的重影减去已经结束的长方形的边的投影承上两条扫描线的间距。再把这些乘积加在一起。

　　下面就将如何实现了，首先我们可以想到用线段树求区间和来求这些投影的长度，那么区间如此之大（-1e8~1e8），怎么能建树呢？不会空间爆炸吗？所以就应该运用动态开点线段树，算一下每一个扫描线开一个节点，那么就是n个，一共有log21e8层所以是可以开的下的。根据这个说法，每一条边应该进行排序，由于扫描是从左到右，所以排序应该是把横坐标从小到大排序，所以每条边有三个属性：位置即横坐标，从那个点开始，从那个点结束，这两给点分别是纵坐标的两个端点。

struct Line
{
    int from,to,x,val; 
}line[2001];
bool cmp1(const Line &a,const Line &b)
{
    return a.x<b.x;
}
int main()
{
    scanf("%d",&n);
    for(int i=1;i<=n;i++)
    {
        scanf("%d%d%d%d",&a,&b,&c,&d);
        line[i*2-1].x=a;
        line[i*2-1].from=d+1;
        line[i*2-1].to=b;
        line[i*2-1].val=1;
        line[i*2].x=c;
        line[i*2].from=d+1;
        line[i*2].to=b;
        line[i*2].val=-1;
    }
    sort(line+1,line+1+2*n,cmp1);
}
 
扫描线排序

下面讲解一下如何把线段树运用进去，我们把每一条边给定一个属性，这个矩形的左面边定义为入边，给一个+1的值，右边的边定义为出边，给一个-1的值，这就是边里的val的意义，那么这个和线段树又有什么关系呢？有了这个值我们可以快速地直接给线段树赋值，让其显示是否有边覆盖在上面，也就是下面代码中的cover数组的含义，如果cover数组有值不是零，那么这个区间就有边，即有r-l+1的贡献，否则则没有。这便是查询。在查询中一定要查到叶子节点，因为在扫描线中是没有上传值或是下传值的说法。

int find(int l,int r,int p)
{
    if(cover[p])
        return sum[p];
    if(lp==rp&&rp==0)
        return 0;
    int sum=0;
    if(lp!=0)
        sum+=find(l,(l+r)>>1,lp);
    if(rp!=0)
        sum+=find(((l+r)>>1)+1,r,rp);
    return sum;
}
 
扫描线查询

最难的要数修改，如果现在的节点被现在要加的边完全覆盖，那么直接修改就好啦，否则要递归的寻找他的儿子，如果没有儿子则动态开点出来，这边是修改的想法，当然在修改时不要忘记修改cover的值。

void change(int l,int r,int x,int y,int &p,int delta)
{
    if(!p)
        p=++cnt;
    if(x<=l&&r<=y)
    {
        cover[p]+=delta;
        sum[p]=r-l+1;
        return;
    }
    int mid=(l+r)>>1;
    if(x<=mid)
        change(l,mid,x,y,lp,delta);
    if(y>mid)
        change(mid+1,r,x,y,rp,delta);
}
 
扫描线修改