Atlantis POJ1151（N^2算法）

题目大意
给你n个矩形，让你求所有矩形覆盖的总面积，重叠的地方只算一次
输入格式
输入的第一行包含一个整数n，表示可得到的地图数目。
以下n行，每行描述一张地图。每行包含4个整数x1,y1,x2和y2（0≤x1＜x2≤30000,0≤y1＜y2≤30000）。数值（x1,y1）和（x2，y2）是坐标，分别表示绘制区域的左下角和右上角坐标。每张地图是矩形的，并且它的边是平行于x坐标轴或y坐标轴的。
数据可能有多组，当n为零时停止输入
输出格式
对于每个测试数据，你的程序应该输出一个答案。每个答案的第一行必须是“Test case #k”，其中k是测试数据的编号(从1开始)。第二个必须是“Total explored area: a”，其中a是总探索面积(即在本测试案例中所有矩形的并集面积)，精确到小数点右边两位。
在每个测试用例后输出一个空行。
样例输入
2
10 10 20 20
15 15 25 25.5
0

样例输出
Test case #1
Total explored area:180.00

#include<iostream>
#include<cstdio>
#include<cstring>
#include<cstdlib>
using namespace std;
struct rec{double x;int to,e;}a[210],b[210];
int c[110][2],f[210],n,i,j,k,x,y,z,data;
double len,ans,x1,y1,x2,y2;

int cmp(const void *a,const void *b)
{
	return ((rec *)a)->x>((rec *)b)->x?1:-1;
}

int main()
{
	while(cin>>n&&n)
	{
		for(i=1;i<=n;i++) 
		{
			scanf("%lf%lf%lf%lf",&x1,&y1,&x2,&y2);
			a[i*2-1].x=x1; a[i*2-1].to=i; a[i*2-1].e=1;
			a[i*2].x=x2; a[i*2].to=i; a[i*2].e=-1;
			b[i*2-1].x=y1; b[i*2-1].to=i; b[i*2-1].e=0;
			b[i*2].x=y2; b[i*2].to=i; b[i*2].e=1;
		}
		/*a数组存储横坐标，b数组存储纵坐标，结构体x成员表示左边值，
		to记录第几个矩形，e记录矩形是哪个边，对于第i个矩形，左下角
		横坐标、纵坐标分别保存在a[i*2-1]、b[i*2-1]中，右上角的坐标
		分别保存在a[i*2]、b[i*2]中。
        垂直扫描线，a[i].e是1表示矩形左边，也就是入边，a[i].e=-1表示
        矩形的右边，也就是出边，关键是维护纵坐标的变化。
        */
		qsort(b+1,2*n,sizeof(b[1]),cmp);
		qsort(a+1,2*n,sizeof(a[1]),cmp);
		for(i=1;i<=2*n;i++) c[b[i].to][b[i].e]=i;
		/*c[ ][0]=i或c[ ][1]=i,正好可以把一个矩形的上下两个纵坐标出现的位置放在
		二维数组的一行内，并不是连续放的，只要上面的循环结束后，那么每行
		放矩形的两个纵坐标排序后的位置。
		b[ ]数组经过排序后，出现的纵坐标就被打乱了，也就是b[1] ，b[2]不一定
		是第一个矩形的两个纵坐标。
		经过c[b[i].to][b[i].e]=i;这条语句后，b[i].to=1，第一个矩形的信息还是
		放在二维数组c的第一行，b[i].to=2,第二个矩形还是放在二维数组C的第二行
		*/
		memset(f,0,sizeof(f));
		for(ans=0,i=1;i<2*n;i++)//扫描n个矩形的2n个横坐标
		{
			j=a[i].to; x=c[j][0]; y=c[j][1]; z=a[i].e;
			//j = a[i].to，拿到矩形的横坐标属于哪个矩形
			//z=a[i].e，拿到这个横坐标是入边还是出边
			//x=c[j][0]; y=c[j][1]; 拿到这条边影响的纵坐标 ，如下图，第一个矩形的第一条
			//是入边，x=1，y=4，也就是纵坐标y1到y2，y2到y3，y3到y4这几段都有效
		    for(k=x;k<y;k++) f[k]+=z;
			/*上面的for语句的作用看程序后面的图
			*/
			for(len=0,k=1;k<2*n;k++) if(f[k]) len+=b[k+1].x-b[k].x;
			ans+=len*(a[i+1].x-a[i].x);
		}
		printf("Test case #%d\nTotal explored area: %.2f\n\n",++data,ans);
	}
	return 0;
}

补充：
qsort的7种用法（转）
七种qsort排序方法
<本文中排序都是采用的从小到大排序>

一、对int类型数组排序

int num[100];

Sample:

int cmp ( const void *a , const void *b )
{
return *(int *)a - *(int *)b;
}

qsort(num,100,sizeof(num[0]),cmp);

二、对char类型数组排序（同int类型）

char word[100];

Sample:

int cmp( const void *a , const void *b )
{
return *(char *)a - *(int *)b;
}

qsort(word,100,sizeof(word[0]),cmp);

三、对double类型数组排序（特别要注意）

double in[100];

int cmp( const void *a , const void *b )
{
return *(double *)a > *(double *)b ? 1 : -1;
}

qsort(in,100,sizeof(in[0]),cmp)；

四、对结构体一级排序

struct In
{
double data;
int other;
}s[100]

//按照data的值从小到大将结构体排序,关于结构体内的排序关键数据data的类型可以很多种，参考上面的例子写

int cmp( const void *a ,const void b)
{
return ((In )a).data > ((In *)b).data ? 1 : -1;
}

qsort(s,100,sizeof(s[0]),cmp);

五、对结构体二级排序

struct In
{
int x;
int y;
}s[100];

//按照x从小到大排序，当x相等时按照y从大到小排序

int cmp( const void *a , const void *b )
{
struct In *c = (In *)a;
struct In *d = (In *)b;
if(c->x != d->x) return c->x - d->x;
else return d->y - c->y;
}

qsort(s,100,sizeof(s[0]),cmp);

六、对字符串进行排序

struct In
{
int data;
char str[100];
}s[100];

//按照结构体中字符串str的字典顺序排序

int cmp ( const void *a , const void b )
{
return strcmp( ((In )a)->str , ((In *)b)->str );
}

qsort(s,100,sizeof(s[0]),cmp);

七、计算几何中求凸包的cmp

int cmp(const void *a,const void *b) //重点cmp函数，把除了1点外的所有点，旋转角度排序
{
struct point *c=(point *)a;
struct point *d=(point *)b;
if( calc(*c,*d,p[1]) < 0) return 1;
else if( !calc(*c,*d,p[1]) && dis(c->x,c->y,p[1].x,p[1].y) < dis(d->x,d->y,p[1].x,p[1].y)) //如果在一条直线上，则把远的放在前面
return 1;
else return -1;
}