hdu 1255（线段树+离散化）

覆盖的面积

Time Limit: 10000/5000 MS (Java/Others)    Memory Limit: 65536/32768 K (Java/Others)

[align=left]Problem Description[/align]
给定平面上若干矩形,求出被这些矩形覆盖过至少两次的区域的面积.



 

[align=left]Input[/align]
输入数据的第一行是一个正整数T(1<=T<=100),代表测试数据的数量.每个测试数据的第一行是一个正整数N(1<=N<=1000),代表矩形的数量,然后是N行数据,每一行包含四个浮点数,代表平面上的一个矩形的左上角坐标和右下角坐标,矩形的上下边和X轴平行,左右边和Y轴平行.坐标的范围从0到100000.

注意:本题的输入数据较多,推荐使用scanf读入数据.

 

[align=left]Output[/align]
对于每组测试数据,请计算出被这些矩形覆盖过至少两次的区域的面积.结果保留两位小数.

 

[align=left]Sample Input[/align]

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

 

[align=left]Sample Output[/align]

7.63
0.00

 
解题思路：这道题目我完全没有思路，后面只能搜别人的解题报告了。。可惜还是没有弄懂。。
线段树的节点包含以下几部分
左右边界l,r此区间被改的次数count,被覆盖一次的长度len，覆盖多次的
长度nlen
每条平行与Y轴直线包括这条线段，x坐标，上下y坐标，还有标记它是前线段
还是后线段的flag;
首先将矩形上所有的Y坐标完全映射到Y坐标上离散化，剔除重复值
建立线段树
存储平行于Y轴的直线
然后检查每条线段，算出面积
面积累加
len（）函数是更新一次覆盖的长度
nlen（）函数是更新覆盖多次的长度

我们假设len[2]为当前线段被覆盖了两次的长度，len[1]为当前线段被覆盖了一次的长度，而len[0]就是这条线段的长度，并且满足len[2]+len[1]=len[0]。
        首先，如果当前这条线段已经被覆盖了两次了，那么这条线段的len[2]就应该等于len[0]，而len[1]就应该等于0。
        其次，如果当前这条线段被覆盖了一次，那么这条线段的len[2]就应该是，左右子线段的len[2]的和加上左右子线段的len[1]，当然，前提是当前线段不能是线段树中的叶子结点，否则它就没有左右子线段不是吗？这时候，当前线段的len[2]就应该等于0。而len[1]就等于len[0]，最后要注意当前线段的len[1]要减去len[2]，以满足len[1]+len[2]=len[0]。
        最后，如果这条线段没有被覆盖过，并且当前线段不是线段树里的叶子结点，那么它的len[1]和len[2]都应该从它的左右子线段的len[1]和len[2]得到，如果是叶子结点，那么len[1]和len[2]都等于0。

AC:

#include<stdio.h>
#include<algorithm>
using namespace std;
#define MAX 1100
typedef struct
{
double x,y1,y2;
__int64 flag;
}LINE;
typedef struct
{
__int64 l,r,count;
double len,nlen;

}NODE;
LINE line[2*MAX];
NODE T[10*MAX];
double Y[2*MAX],tem[2*MAX];
bool comp(LINE a,LINE b)
{
if(a.x<b.x)return true;
if(a.x==b.x&&a.flag<b.flag)return true;
return false;
}
void Build__tree(__int64 i,__int64 l,__int64 r)
{
T[i].l=l;T[i].r=r;
T[i].len=T[i].nlen=0;
T[i].count=0;
if(l+1==r)
return;
__int64 mid;
mid=(l+r)/2;
Build__tree(2*i,l,mid);
Build__tree(2*i+1,mid,r);
}
void Len(__int64 root)
{
if(T[root].count>0)
T[root].len=Y[T[root].r]-Y[T[root].l];
else
T[root].len=T[2*root].len+T[2*root+1].len;

}
void nLen(__int64 root)
{
if(T[root].count>1)
T[root].nlen=Y[T[root].r]-Y[T[root].l];
else if(T[root].count==1)
T[root].nlen=T[root*2].len+T[root*2+1].len;
else
T[root].nlen=T[root*2].nlen+T[root*2+1].nlen;

}
void Update(__int64 root,LINE L)
{
if(L.y1==Y[T[root].l]&&L.y2==Y[T[root].r])
{
T[root].count+=L.flag;
Len(root);
nLen(root);
return ;
}
LINE L1,L2;
if(L.y1>=Y[T[2*root+1].l])
Update(2*root+1,L);
else if(L.y2<=Y[T[2*root].r])
Update(2*root,L);
else
{
L1=L2=L;
L1.y2=Y[T[2*root].r];
L2.y1=Y[T[2*root+1].l];
Update(2*root,L1);
Update(2*root+1,L2);
}
Len(root);
nLen(root);
}
int main()
{
__int64 t,N,i,k;
scanf("%I64d",&t);
while(t--)
{
double x1,x2,y1,y2;
__int64 j;
scanf("%I64d",&N);
for(i=1,k=1;i<=N;i++)
{
scanf("%lf%lf%lf%lf",&x1,&y1,&x2,&y2);
line[k].x=x1;line[k].y1=y1;line[k].y2=y2;line[k].flag=1;
tem[k++]=y1;
line[k].x=x2;line[k].y1=y1;line[k].y2=y2;line[k].flag=-1;
tem[k++]=y2;
}
sort(line+1,line+2*N+1,comp);
sort(tem+1,tem+2*N+1);
j=1;
Y[1]=tem[1];
for(i=2;i<=2*N;i++)
{
if(tem[i]==tem[i-1])
continue;
Y[++j]=tem[i];
}
Build__tree(1,1,j);
double area=0;
for(i=1;i<=2*N;i++)
{
if(i>1)
area=area+(line[i].x-line[i-1].x)*T[1].nlen;
Update(1,line[i]);

}
printf("%.2lf\n",area);
}
return 0;
}