并矩形覆盖的面积

 *************************

优秀博客系列: http://blog.csdn.net/dooder_daodao/article/details/6334169

**************************

Poj1151/HDU1542(求并矩形覆盖的面积)分别用离散化处理,矩形切割,线段树三种方法实现.

题目链接:http://poj.org/problem?id=1151

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

题意:给出任意n多矩形,求其总覆盖的面积.

可分别用离散化处理,矩形切割,线段树三种方法实现,以下分别为三种方法的代码:

离散化坐标:

#include<stdio.h>
#include<math.h>
#include<string.h>
#include<stdlib.h>
#define M 408
const double eps = 1e-8;
typedef struct{
	double x1,x2,y1,y2;
	void set(double x1,double y1,double x2,double y2)
	{this->x1=x1;this->y1=y1;this->x2=x2;this->y2=y2;}
}Rec;
Rec r[M];
bool map[M][M];
//数组开太小,RE了一次
double x[M],y[M];
int n,nx,ny;
int Cmp(const void *a,const void *b)
{
	return *(double *)a>*(double *)b?1:-1;
}
int Find(double arr[],int low,int up,double v)
{//二分查找,并且一定数组中一定存在与v相等的值
	int mid=(low+up)>>1;
	if(fabs(arr[mid]-v)<eps) return mid;
	if(arr[mid]>v) return Find(arr,low,mid-1,v);
	return Find(arr,mid+1,up,v);
}
int main()
{
	double x1,y1,x2,y2,ans;
	int t=1,i,j,i1,i2,j1,j2,k;
	while(scanf("%d",&n),n){
		for(nx=ny=0,i=0;i<n;i++){
			scanf("%lf%lf%lf%lf",&x1,&y1,&x2,&y2);
			r[i].set(x1,y1,x2,y2);
			x[nx++]=x1;x[nx++]=x2;
			y[ny++]=y1;y[ny++]=y2;
		}
		//排序,进而离散化点
		qsort(x,nx,sizeof(x[0]),Cmp);
		qsort(y,ny,sizeof(y[0]),Cmp);
		//消除相等的值,进行离散化
		for(i=0,j=0;i<nx;i++){
			if(fabs(x[i]-x[j])<eps) continue;
			x[++j]=x[i];
		}nx=j;
		for(i=0,j=0;i<ny;i++){
			if(fabs(y[i]-y[j])<eps) continue;
			y[++j]=y[i];
		}ny=j;
		memset(map,false,sizeof(map));
		for(i=0;i<n;i++){
			i1=Find(x,0,nx,r[i].x1);
			i2=Find(x,0,nx,r[i].x2);
			j1=Find(y,0,ny,r[i].y1);
			j2=Find(y,0,ny,r[i].y2);
			for(j=i1;j<i2;j++){//标记覆盖的区域
				for(k=j1;k<j2;k++)
					map[j][k]=true;
			}
		}
		ans=0.0;
		for(i=0;i<nx;i++){
			for(j=0;j<ny;j++){
				if(map[i][j])
					ans+=(x[i+1]-x[i])*(y[j+1]-y[j]);
			}
		}
		printf("Test case #%d/n",t++);
		printf("Total explored area: ");
		printf("%.2f/n/n",ans);
	}
	return 0;
}

矩形切割:

#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#define M 108
typedef struct talRec{
	double x1,y1,x2,y2;
	talRec *next;
}Rec;
Rec space[M*24];//手动分配空间
Rec *list;
int n;
double min(double a,double b)
{
	return a<b?a:b;
}
double max(double a,double b)
{
	return a>b?a:b;
}
void Init()
{//重置内存空间
	int i;
	for(i=0;i<24*n;i++)
		space[i].next=&space[i+1];
	list=&space[1];list->next=NULL;
	space[0].next=&space[2];
}
void Del(Rec *cur)
{//把删掉的结点放入内存分配的链表中
	cur->next=space[0].next;
	space[0].next=cur;
}
void Add(double x1,double y1,double x2,double y2)
{//向链表中插入新矩形,头插法
	
	Rec *cur;
	//new Rec *
	cur=space[0].next;//申请新结点
	space[0].next=cur->next;
	
	cur->x1=x1;cur->y1=y1;
	cur->x2=x2;cur->y2=y2;
	cur->next=list->next;
	list->next=cur;
}
void Cut(double x1,double y1,double x2,double y2,
		 double x3,double y3,double x4,double y4)
{//其中点分别为矩形左下侧点和右上侧点
	double k1,k2,k3,k4;
	
	if(x2<=x3||y2<=y3||x4<=x1||y4<=y1){
		Add(x1,y1,x2,y2);//如果不相交
		return ;
	}
	k1=max(x1,x3);k2=min(x2,x4);
	if(x1<k1) Add(x1,y1,k1,y2);
	if(x2>k2) Add(k2,y1,x2,y2);
	k3=k1,k4=k2;
	k1=max(y1,y3);k2=min(y2,y4);
	if(y1<k1) Add(k3,y1,k4,k1);
	if(y2>k2) Add(k3,k2,k4,y2);
}
void New(double x1,double y1,double x2,double y2)
{//添加新矩形时,与之前的矩形比较,切割
	Rec *cur,*pre,*tmp;
	
	pre=list;cur=pre->next;
	while(cur){
		pre->next=cur->next;//删掉当前与之比较的链表中的矩形
		if(pre==list){
			tmp=cur->next;
			Cut(cur->x1,cur->y1,cur->x2,cur->y2,x1,y1,x2,y2);
			while(pre->next!=tmp) pre=pre->next;
		}
		else Cut(cur->x1,cur->y1,cur->x2,cur->y2,x1,y1,x2,y2);
		Del(cur);
		cur=pre->next;
	}
	Add(x1,y1,x2,y2);
}
int main()
{
	double x1,y1,x2,y2,ans,tmp;
	int t=1;
	while(scanf("%d",&n),n){
		Init();//
		while(n--){
			scanf("%lf%lf%lf%lf",&x1,&y1,&x2,&y2);
			if(x1>x2) tmp=x1,x1=x2,x2=tmp;
			if(y1>y2) tmp=y1,y1=y2,y2=tmp;
			New(x1,y1,x2,y2);
		}
		for(list=list->next,ans=0.0;list;list=list->next)
			ans+=(list->x2-list->x1)*(list->y2-list->y1);
		printf("Test case #%d/n",t++);
		printf("Total explored area: ");
		printf("%.2f/n/n",ans);
	}
	return 0;
}

线段树加扫描线:

 

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<math.h>
//部分宏定义,左子树,右子树,中间值
#define L(i) (i<<1)
#define R(i) (i<<1|1)
#define Mid(x,y) ((x+y)>>1)
#define M 2010
#define eps 1e-8
typedef struct {//垂线定义,即扫描线
	double x,y1,y2;
	int flag;
}Line;
typedef struct {//线段树结点定义
	int l,r,c;
	double ln;
}SegTree;
Line line[M];
SegTree seg[M*3];
double y[M];
int ls,ys;
int cmp1(const void *a,const void *b)
{
	Line *p=(Line *)a;
	Line *q=(Line *)b;
	if(fabs(p->x-q->x)<eps)
		return p->flag-q->flag;
	return p->x>q->x?1:-1;
}
int cmp2(const void *a,const void *b)
{
	return *(double *)a>*(double *)b?1:-1;
}
void Create(int i,int l,int r)
{//构建一个空的线段树
	seg[i].l=l;seg[i].r=r;
	seg[i].ln=0.0;seg[i].c=0;
	if(l==r-1)
		return ;
	int mid=Mid(l,r);
	Create(L(i),l,mid);
	Create(R(i),mid,r);
}
void Calen(int i)
{//更新当前结点段,y轴上覆盖的长度
	if(seg[i].c>0){
		seg[i].ln=y[seg[i].r]-y[seg[i].l];
		return ;
	}
	if(seg[i].r-seg[i].l==1)
		seg[i].ln=0.0;
	else seg[i].ln=seg[L(i)].ln+seg[R(i)].ln;
}
void Updata(int i,Line l)
{//向线段树增加新的线段
	Line tmp;
	int mid;
	if(fabs(l.y1-y[seg[i].l])<eps&&fabs(l.y2-y[seg[i].r])<eps){
		seg[i].c+=l.flag;
		Calen(i);
		return ;
	}
	mid=Mid(seg[i].l,seg[i].r);
	if(fabs(l.y2-y[mid])<eps||l.y2<y[mid])
		Updata(L(i),l);
	else if(fabs(l.y1-y[mid])<eps||l.y1>y[mid])
		Updata(R(i),l);
	else {
		tmp.flag=l.flag;
		tmp.y1=l.y1;tmp.y2=y[mid];
		Updata(L(i),tmp);
		tmp.y1=y[mid];tmp.y2=l.y2;
		Updata(R(i),tmp);
	}
	Calen(i);
}
int main()
{
	int t=1,n;
	int i,j;
	double x1,x2,y1,y2;
	double ans;
	
	while(scanf("%d",&n),n){
		ls=1;
		for(i=0;i<n;i++){
			scanf("%lf%lf%lf%lf",&x1,&y1,&x2,&y2);
			line[ls].x=x1;line[ls].y1=y1;
			line[ls].y2=y2;line[ls].flag=1;
			line[ls+1].x=x2;line[ls+1].y1=y1;
			line[ls+1].y2=y2;line[ls+1].flag=-1;
			y[ls++]=y1;y[ls++]=y2;
		}
		qsort(line+1,ls-1,sizeof(line[0]),cmp1);
		qsort(y+1,ls-1,sizeof(y[0]),cmp2);
		
		for(i=1,j=1;i<ls;i++){//y轴坐标离散化,此处消去相同的y值
			if(fabs(y[j]-y[i])<eps)	continue;
			y[++j]=y[i];
		}ys=j;
		Create(1,1,ls-1);
		ans=0;
		for(i=1;i<ls;i++){//求面积
			ans+=seg[1].ln*(line[i].x-line[i-1].x);
			Updata(1,line[i]);
		}
		printf("Test case #%d/n",t++);
		printf("Total explored area: ");
		printf("%.2f/n/n",ans);
	}
	return 0;
}

 

其实,还有好几种做法~~~什么二维线段树,什么方块树~呃,以后再研究~

HDOJ 3265 Posters （线段树+扫描线求矩形面积并）

题意：给n个矩形，每个矩形都有一个矩形的“洞”，矩形和洞的边都与坐标轴平行，求这些带“洞”的矩形覆盖的面积。

数据范围：n<=50000, 0<=x,y<=50000

分析：这题本质还是求矩形面积并，因为一个带“洞”的矩形可以看成是4个矩形。由于矩形数目n和坐标范围均比较大，所以离散化+暴力统计的方法肯定会超时。扫描线的方法我也是第一次学，我的理解是这样的，把所有矩形的2条竖直边（横边也一样）无限延伸就得到扫描线，这些线把所有矩形重新划分为许多不相交的矩形，所有矩形的面积并其实就是夹在这些线之间的矩形的面积之和，夹缝中的矩形的宽就是扫描线之间的距离，关键在于夹缝中矩形的高度是多少？这就要用到线段树了，由于坐标范围和矩形数目是一个数量级的，所以不离散化应该也没关系（我写了离散化）。线段树是根据y轴来建的，保存的关键信息就是当前夹缝中的矩形的高，其实就是区间的覆盖长度，另需保存区间被覆盖的次数以便更新。将从左到有扫描竖线，碰到矩形的左边竖线就覆盖到区间中，碰到右边竖线就将其从区间中删除，这样的话每次查询的区间被覆盖的长度就是夹缝中矩形的高。

注意：

1、建树之前要判断y方向上的坐标数目是否小于2，小于2时若建树会RE。其实小于2说明结果是0

2、最大面积为500000*50000，超了int，可以用unsigned int

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#define N 200010
int n;
struct scan
{
    int x,yl,yu,flag;
};
scan scanline[2*N];
int xcnt;
int cnt[4*2*N],len[4*2*N];
int y[2*N],ycnt;
int cmp1(const void *a,const void *b)
{
    return *(int*)a-*(int*)b;
}
int cmp2(const void *a,const void *b)
{
    scan *c=(scan *)a;
    scan *d=(scan *)b;
    return (c->x)-(d->x);
}
void init()
{
    xcnt=ycnt=0;
}
void add(int a,int b,int c,int d)
{
    scanline[xcnt].x=a;
    scanline[xcnt].yl=b;
    scanline[xcnt].yu=d;
    scanline[xcnt++].flag=1;

    scanline[xcnt].x=c;
    scanline[xcnt].yl=b;
    scanline[xcnt].yu=d;
    scanline[xcnt++].flag=0;

    y[ycnt++]=b;    y[ycnt++]=d;
}
void read()
{
    int i,j;
    int x[8];
    for(i=0;i<n;i++)
    {
        for(j=0;j<8;j++)    scanf("%d",&x[j]);
        if(x[0]<x[4] && x[1]<x[3])    add(x[0],x[1],x[4],x[3]);
        if(x[6]<x[2] && x[1]<x[3])    add(x[6],x[1],x[2],x[3]);
        if(x[4]<x[6] && x[7]<x[3])    add(x[4],x[7],x[6],x[3]);
        if(x[4]<x[6] && x[1]<x[5])    add(x[4],x[1],x[6],x[5]);
    }
}
int bs(int k)
{
    int min=0,max=ycnt,mid;
    while(min+1!=max)
    {
        mid=min+max>>1;
        if(y[mid]>k)    max=mid;
        else    min=mid;
    }
    return min+1;
}

void update(int cur,int l,int r)
{
    int ls=cur<<1,rs=cur<<1|1;
    if(cnt[cur]>0)  len[cur]=y[r-1]-y[l-1];
    else if(l+1==r) len[cur]=0;
    else    len[cur]=len[ls]+len[rs];
}
void build(int cur,int l,int r)
{
    int mid=l+r>>1,ls=cur<<1,rs=cur<<1|1;
    cnt[cur]=0;
    len[cur]=0;
    if(l+1==r)  return;
    build(ls,l,mid);
    build(rs,mid,r);
}
void insert(int cur,int l,int r,int s,int t)
{
    int mid=l+r>>1,ls=cur<<1,rs=cur<<1|1;
    if(l>=s && r<=t)
    {
        cnt[cur]++;
        update(cur,l,r);
        return;
    }

    if(mid>s)   insert(ls,l,mid,s,t);
    if(mid<t)   insert(rs,mid,r,s,t);
    update(cur,l,r);
}
void del(int cur,int l,int r,int s,int t)
{
    int mid=l+r>>1,ls=cur<<1,rs=cur<<1|1;
    if(l>=s && r<=t)
    {
        cnt[cur]--;
        update(cur,l,r);
        return;
    }

    if(mid>s)   del(ls,l,mid,s,t);
    if(mid<t)   del(rs,mid,r,s,t);
    update(cur,l,r);
}

void solve()
{
    qsort(y,ycnt,sizeof(y[0]),cmp1);
    qsort(scanline,xcnt,sizeof(scanline[0]),cmp2);

    int i,j,k;
    k=ycnt;
    ycnt=0;
    y[ycnt++]=y[0];
    for(i=1;i<k;i++)    if(y[ycnt-1]^y[i])  y[ycnt++]=y[i];

    if(ycnt<2)  {   puts("0");  return; }

    unsigned int ans=0;
    build(1,1,ycnt);
    for(k=0;k<xcnt-1;k++)
    {
        i=scanline[k].yl;   i=bs(i);
        j=scanline[k].yu;   j=bs(j);
        if(scanline[k].flag)    insert(1,1,ycnt,i,j);
        else    del(1,1,ycnt,i,j);

        i=scanline[k].x;
        j=scanline[k+1].x;
        ans+=len[1]*(j-i);
    }
    printf("%u\n",ans);
}
int main()
{
    while(scanf("%d",&n),n)
    {
        init();
        read();
        solve();
    }
    return 0;
}

********************************************************

UVA11983——线段树求矩形覆盖K次以上面积并

 

 

给出N个矩形（1<=N<=30,000），求被这些矩形覆盖K次以上的区域面积。

跟矩形面积并一样的思路，不过记录的节点信息多一点，除了要记录区间覆盖次数，还要记录以该节点为根的子树上，覆盖次数为i的长度s[i]有多少。因为K很小只有10,而30000*4*10完全可以承受。