POJ 1151 Atlantis (扫描线+线段树)

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

题意是平面上给你n个矩形，让你求矩形的面积并。

首先学一下什么是扫描线：http://www.cnblogs.com/scau20110726/archive/2013/04/12/3016765.html

这是别人的blog，写的挺好的。然后明白扫描线之后呢，接下来就很简单了，只需要一次一次求面积然后累加就好了。这题离散化之后，数据的范围更小了(因为n只有100)，单点更新就行了。

#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <map>
using namespace std;
const int MAXN = 2e2 + 5;
struct data {
    double x1 , x2;
    double y;
    int xx1 , xx2 , flag;  //flag: 1表示加 -1表示减    xx1 xx2是离散化之后的值
    bool operator <(const data& cmp) const {
        return y < cmp.y;
    }
}edge[MAXN << 2];
struct segtree {
    int l , r , lazy; //lazy表示累加的次数
    double val; //val表示长度
}T[MAXN << 2];
double x[MAXN];
map <double , int> mp;

double min(double a , double b) {
    return a > b ? b : a;
}

double max(double a , double b) {
    return a > b ? a : b;
}

void init(int p , int l , int r) {
    int mid = (l + r) >> 1;
    T[p].l = l , T[p].r = r , T[p].val = T[p].lazy = 0;
    if(r - l == 1) {
        return ;
    }
    init(p << 1 , l , mid);
    init((p << 1)|1 , mid , r);
}

void updata(int p , int l , int r , int val) {
    int mid = (T[p].l + T[p].r) >> 1;
    if(T[p].r - T[p].l == 1) {
        if(val == -1) {
            T[p].lazy--;
            T[p].val = T[p].lazy ? (x[T[p].r] - x[T[p].l]) : 0;
        }
        else {
            T[p].lazy++;
            T[p].val = (x[T[p].r] - x[T[p].l]);
        }
        return ;
    }
    if(r <= mid) {
        updata(p << 1 , l , r , val);
    }
    else if(l >= mid) {
        updata((p << 1)|1 , l , r , val);
    }
    else {
        updata(p << 1 , l , mid , val);
        updata((p << 1)|1 , mid , r , val);
    }
    T[p].val = T[p << 1].val + T[(p << 1)|1].val;
}

int main()
{
    int n , ca = 1;
    double x1 , x2 , y1 , y2;
    while(~scanf("%d" , &n) && n) {
        int cont = 0;
        mp.clear();
        for(int i = 0 ; i < n ; i++) {
            scanf("%lf %lf %lf %lf" , &x1 , &y1 , &x2 , &y2);
            edge[i * 2].x1 = min(x1 , x2) , edge[i * 2].x2 = max(x1 , x2);
            edge[i * 2].y = min(y1 , y2);
            edge[i * 2].flag = 1;
            edge[i * 2 + 1].x1 = edge[i * 2].x1 , edge[i * 2 + 1].x2 = edge[i * 2].x2;
            edge[i * 2 + 1].y = max(y1 , y2);
            edge[i * 2 + 1].flag = -1;
            if(!mp[x1]) {
                x[++cont] = x1;
                mp[x1]++;
            }
            if(!mp[x2]) {
                x[++cont] = x2;
                mp[x2]++;
            }
        }
        sort(edge , edge + n * 2);
        sort(x + 1 , x + cont + 1);
        for(int i = 0 ; i < n * 2 ; i++) {
            int pos = (lower_bound(x + 1 , x + cont + 1 , edge[i].x1) - x);
            edge[i].xx1 = pos;
            pos = (lower_bound(x + 1 , x + cont + 1 , edge[i].x2) - x);
            edge[i].xx2 = pos;
        }
        init(1 , 1 , cont);
        double res = 0;
        updata(1 , edge[0].xx1 , edge[0].xx2 , edge[0].flag);
        for(int i = 1 ; i < n * 2 ; i++) {
            res += T[1].val * (edge[i].y - edge[i - 1].y);
            updata(1 , edge[i].xx1 , edge[i].xx2 , edge[i].flag);
        }
        printf("Test case #%d
" , ca++);
        printf("Total explored area: %.2f

" , res);
    }
}