poj 1151 Atlantis(离散+线段树)

http://poj.org/problem?id=1151

 　　数据量比较小，不过也是可以先离散坐标，再构建线段树，然后用扫描线在每个关键位置插入/删除线段并进行面积相加。

#include <cstdio>
#include <cstring>
#include <algorithm>
#include <map>
#include <vector>

using namespace std;

map<double, int> id;
vector<double> x;
struct Rect {
    double x1, x2, y;
    bool end;
} ;
vector<Rect> rect;
const int maxn = 300;
double sum[maxn << 2];
int late[maxn << 2], mx[maxn << 2], mn[maxn << 2];

bool cmp(const Rect a, const Rect b) {
    return a.y < b.y;
}

void input(int n) {
    double x1, y1, x2, y2;
    Rect tmp;

    rect.clear();
    x.clear();
    id.clear();
    for (int i = 0; i < n; i++) {
        scanf("%lf%lf%lf%lf", &x1, &y1, &x2, &y2);
        if (x1 > x2) swap(x1, x2);
        if (y1 > y2) swap(y1, y2);
        tmp.x1 = x1, tmp.x2 = x2, tmp.y = y1, tmp.end = false;
        rect.push_back(tmp);
        tmp.y = y2, tmp.end = true;
        rect.push_back(tmp);
        x.push_back(x1);
        x.push_back(x2);
    }
//    for (int i = 0, endi = x.size(); i < endi; i++) {
//        printf("%.3f\n", x[i]);
//    }
    sort(x.begin(), x.end());
    sort(rect.begin(), rect.end(), cmp);
    x.end() = unique(x.begin(), x.end());

    for (int i = 0, endi = x.size(); i < endi; i++) {
        id[x[i]] = i;
    }

//    for (int i = 0, endi = x.size(); i < endi; i++) {
//        printf("%.3f %d\n", x[i], id[x[i]]);
//    }
}

#define lson l, m, rt << 1
#define rson m, r, rt << 1 | 1

void up(int rt) {
    int ls = rt << 1, rs = rt << 1 | 1;

    mn[rt] = min(mn[ls], mn[rs]);
    mx[rt] = max(mx[ls], mx[rs]);
    sum[rt] = sum[ls] + sum[rs];
}

void down(int rt, int l, int r) {
    if (late[rt]) {
        int ls = rt << 1, rs = rt << 1 | 1;
        int m = (l + r) >> 1;

        mx[ls] += late[rt];
        mn[ls] += late[rt];
        if (mn[ls]) {
            sum[ls] = x[m] - x[l];
        }
        if (!mx[ls]) {
            sum[ls] = 0.0;
        }
        mx[rs] += late[rt];
        mn[rs] += late[rt];
        if (mn[rs]) {
            sum[rs] = x[r] - x[m];
        }
        if (!mx[rs]) {
            sum[rs] = 0.0;
        }
        late[ls] += late[rt];
        late[rs] += late[rt];
        late[rt] = 0;
    }
}

void build(int l, int r, int rt) {
    sum[rt] = 0.0;
    mx[rt] = mn[rt] = late[rt] = 0;
    if (r - l == 1) {
        return ;
    }
    int m = (l + r) >> 1;

    build(lson);
    build(rson);
}

void fix(int l, int r, int rt) {
    if (r - l == 1 || mn[rt] || mn[rt] == mx[rt]) {
        if (!mx[rt]) sum[rt] = 0.0;
        if (mn[rt]) sum[rt] = x[r] - x[l];
        return ;
    }
    int m = (l + r) >> 1;

    down(rt, l, r);
    fix(lson);
    fix(rson);
    up(rt);
}

void update(int L, int R, int k, int l, int r, int rt) {
//    printf("%d %d\n", l, r);
    if (L <= l && r <= R) {
        mn[rt] += k;
        mx[rt] += k;
        late[rt] += k;
        if (mn[rt]) sum[rt] = x[r] - x[l];
        if (!mx[rt]) sum[rt] = 0.0;
        if (!mn[rt] && mx[rt]) fix(l, r, rt);

        return ;
    }
    int m = (l + r) >> 1;

    down(rt, l, r);
    if (L < m) update(L, R, k, lson);
    if (m < R) update(L, R, k, rson);
    up(rt);
}

double deal(int n) {
    double ret = 0.0;

    update(id[rect[0].x1], id[rect[0].x2], 1, 0, x.size(), 1);
    for (int i = 1, endi = rect.size(); i < endi; i++) {
        ret += sum[1] * (rect[i].y - rect[i - 1].y);
//        printf("%.2f %.2f\n", ret, sum[1]);
//        printf("%d %d\n", id[rect[i].x1], id[rect[i].x2]);
//        printf("%d\n", x.size());
        if (rect[i].end) {
            update(id[rect[i].x1], id[rect[i].x2], -1, 0, x.size(), 1);
        } else {
            update(id[rect[i].x1], id[rect[i].x2], 1, 0, x.size(), 1);
        }
    }

    return ret;
}

int main() {
//    freopen("in", "r", stdin);
    int n, cas = 1;

    while (~scanf("%d", &n) && n) {
        input(n);
        build(0, x.size(), 1);
        printf("Test case #%d\nTotal explored area: %.2f\n\n", cas, deal(n << 1));
        cas++;
    }

    return 0;
}

——written by Lyon