HDU1255(KB7-O)

覆盖的面积

Time Limit: 10000/5000 MS (Java/Others)    Memory Limit: 65536/32768 K (Java/Others)
Total Submission(s): 7779    Accepted Submission(s): 3923

Problem Description

给定平面上若干矩形,求出被这些矩形覆盖过至少两次的区域的面积.

 

Input

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

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

 

Output

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

 

Sample Input

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

 

Sample Output

7.63
0.00

 

Author

Ignatius.L & weigang Lee

 

 //2018-09-09
 #include <cstdio>
 #include <cstring>
 #include <iostream>
 #include <algorithm>
 #define lson (id<<1)
 #define rson ((id<<1)|1)
 using namespace std;

 const int N = ;
 const double EPS = 0.0001;

 struct Node{
     double sum;
 }tree[N<<];
 int cnt[N], len;
 double x[N];

 void build(){
     memset(tree, , sizeof(tree));
 }

 void update(int id, int L, int R, int pos, int val){
     if(L==R){
         cnt[pos] += val;
         if(cnt[pos]>)tree[id].sum = x[pos+]-x[pos];
         else tree[id].sum = ;
         return;
     }
     int mid = (L+R)/;
     if(pos <= mid)update(lson, L, mid, pos, val);
     else update(rson, mid+, R, pos, val);
     tree[id].sum = tree[lson].sum+tree[rson].sum;
 }

 struct Line{
     double x0, x1, y;
     int fg;
     bool operator<(const Line l) const{
         return y < l.y;
     }
 }line[N<<];

 int bsearch(int l, int r, int key){
     while(l < r){
         int mid = (l+r)>>;
         if(key <= x[mid])r = mid;
         else l = mid+;
     }
     return l;
 }

 int main()
 {
     int T, n, kase = ;
     scanf("%d",&T);
     while(T--){
         scanf("%d", &n);
         double x0, y0, x1, y1;
         len = ;
         for(int i = ; i <= n; i++){
             scanf("%lf%lf%lf%lf", &x0, &y0, &x1, &y1);
             int a = i*-, b = i*;
             line[a].x0 = x0, line[a].x1 = x1, line[a].y = y0, line[a].fg = ;
             line[b].x0 = x0, line[b].x1 = x1, line[b].y = y1, line[b].fg = -;
             x[++len] = x0, x[++len] = x1;
         }
         n*=;
         sort(x+, x++n);
         sort(line+, line++n);
         memset(cnt, , sizeof(cnt));
         build();
         double ans = ;
         for(int i = ; i <= n; i++){
             ans += tree[].sum*(line[i].y-line[i-].y);
             int l = lower_bound(x+, x++n, line[i].x0)-x;
             int r = lower_bound(x+, x++n, line[i].x1)-x;
             for(int j = l; j < r; j++){
                 update(, , n-, j, line[i].fg);
             }
         }
         printf("%.2lf\n", ans+EPS);
     }

     return ;
 }