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 = 2000;
const double EPS = 0.0001;

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

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

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

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

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

    return 0;
}