POJ 1151 Atlantis（扫描线）

POJ 1151 Atlantis

Description
There are several ancient Greek texts that contain descriptions of the fabled island Atlantis. Some of these texts even include maps of parts of the island. But unfortunately, these maps describe different regions of Atlantis. Your friend Bill has to know the total area for which maps exist. You (unwisely) volunteered to write a program that calculates this quantity.
Input
The input consists of several test cases. Each test case starts with a line containing a single integer n (1 <= n <= 100) of available maps. The n following lines describe one map each. Each of these lines contains four numbers x1;y1;x2;y2 (0 <= x1 < x2 <= 100000;0 <= y1 < y2 <= 100000), not necessarily integers. The values (x1; y1) and (x2;y2) are the coordinates of the top-left resp. bottom-right corner of the mapped area.
The input file is terminated by a line containing a single 0. Don’t process it.
Output
For each test case, your program should output one section. The first line of each section must be “Test case #k”, where k is the number of the test case (starting with 1). The second one must be “Total explored area: a”, where a is the total explored area (i.e. the area of the union of all rectangles in this test case), printed exact to two digits to the right of the decimal point.
Output a blank line after each test case.
Sample Input
2
10 10 20 20
15 15 25 25.5
0
Sample Output
Test case #1
Total explored area: 180.00

AC代码1

/*
【AgOHの算法胡扯】扫描线算法 视频中的方法——魔改线段树
https://www.bilibili.com/video/av63999460
*/
#include<cstdio>
#include<algorithm>

const int N = 210;

double v[N];

struct Line {
    double y, x1, x2;
    int state;

    Line() {}

    Line(double y, double x1, double x2, int state) : y(y), x1(x1), x2(x2), state(state) {}

    bool operator<(const Line &oth) { return y < oth.y; }
} line[N];

struct Node {
    double l, r, len;
    int cover;
} seg[N << 3];

inline int ls(int k) { return k << 1; }

inline int rs(int k) { return k << 1 | 1; }

inline void PushUp(int k) {
    double l = seg[k].l, r = seg[k].r;
    if (seg[k].cover) seg[k].len = seg[k].r - seg[k].l;
    else seg[k].len = seg[ls(k)].len + seg[rs(k)].len;
}

void BuildTree(int l, int r, int k = 1) {
    seg[k].l = v[l], seg[k].r = v[r];
    seg[k].len = 0.0, seg[k].cover = 0;
    if (r - l <= 1) return;
    int m = (l + r) >> 1;
    BuildTree(l, m, ls(k));
    BuildTree(m, r, rs(k));	//这里的左右区间之间没有间隔，即[l,r]分成了 [l,m]和[m,r]两部分
}

void modify(double L, double R, int state, int k = 1) {
    double l = seg[k].l, r = seg[k].r;
    if (L <= l && r <= R) {
        seg[k].cover += state;
        PushUp(k);
        return;
    }
    if (L < seg[ls(k)].r) modify(L, R, state, ls(k));
    if (R > seg[rs(k)].l) modify(L, R, state, rs(k));
    PushUp(k);
}

int main() {
    int n, T = 0;
    double a, b, c, d;
    while (scanf("%d", &n) == 1 && n != 0) {
        for (int i = 1; i <= n; ++i) {
            scanf("%lf%lf%lf%lf", &a, &b, &c, &d);
            v[i] = a, v[n + i] = c;
            line[i] = Line(b, a, c, 1), line[n + i] = Line(d, a, c, -1);
        }
        n <<= 1;
        std::sort(v + 1, v + n + 1);
        std::sort(line + 1, line + n + 1);
        BuildTree(1, n);
        double ans = 0.0;
        for (int i = 1; i <= n; ++i) {
            ans += seg[1].len * (line[i].y - line[i - 1].y);
            modify(line[i].x1, line[i].x2, line[i].state);
        }
        printf("Test case #%d\nTotal explored area: %.2lf\n\n", ++T, ans);
    }
    return 0;
}

AC代码2

#include<cstdio>
#include<algorithm>

using namespace std;
const int N = 222;
double X[N];

struct node {
    double l, r, h;
    int d;

    node() {}

    node(double a, double b, double c, int d) : l(a), r(b), h(c), d(d) {}

    bool operator<(const node &b) const {
        return h < b.h;
    }
} nodes[N];

int cnt[N * 4];
double sum[N * 4];

void PushDown(int i, int l, int r) {
    int m = (l + r) / 2;
    if (cnt[i] != -1) {
        cnt[i * 2] = cnt[i * 2 + 1] = cnt[i];
        sum[i * 2] = (cnt[i] ? (X[m + 1] - X[l]) : 0);
        sum[i * 2 + 1] = (cnt[i] ? (X[r + 1] - X[m + 1]) : 0);
    }
}

void PushUp(int i, int l, int r) {
    if (cnt[i * 2] == -1 || cnt[i * 2 + 1] == -1)
        cnt[i] = -1;
    else if (cnt[i * 2] != cnt[i * 2 + 1])
        cnt[i] = -1;
    else
        cnt[i] = cnt[i * 2];
    sum[i] = sum[i * 2] + sum[i * 2 + 1];
}

void build(int i, int l, int r) {
    if (l == r) {
        cnt[i] = 0;
        sum[i] = 0.0;
        return;
    }
    int m = (l + r) / 2;
    build(i*2,l,m);
    build(i*2+1,m+1,r);	//这里是正常的线段树做法，代码中的[l,r]实际上是表示图中的[l,r+1]
    PushUp(i, l, r);
}

void update(int ql, int qr, int v, int i, int l, int r) {
    if (ql <= l && r <= qr) {
        if (cnt[i] != -1) {
            cnt[i] += v;
            sum[i] = (cnt[i] ? (X[r + 1] - X[l]) : 0);
            return;
        }
    }
    PushDown(i, l, r);
    int m = (l + r) / 2;
    if (ql <= m) update(ql, qr, v, i*2,l,m);
    if (m < qr) update(ql, qr, v, i*2+1,m+1,r);
    PushUp(i, l, r);
}

int bin(double key, int n, double d[]) {
    int l = 1, r = n;
    while (r >= l) {
        int m = (r + l) / 2;
        if (d[m] == key)
            return m;
        else if (d[m] > key)
            r = m - 1;
        else
            l = m + 1;
    }
    return -1;
}

int main() {
    int q;
    int T = 0;
    while (scanf("%d", &q) == 1 && q) {
        int n = 0, m = 0;
        for (int i = 1; i <= q; i++) {
            double x1, y1, x2, y2;
            scanf("%lf%lf%lf%lf", &x1, &y1, &x2, &y2);
            X[++n] = x1;
            nodes[++m] = node(x1, x2, y1, 1);
            X[++n] = x2;
            nodes[++m] = node(x1, x2, y2, -1);
        }
        sort(X + 1, X + n + 1);
        sort(nodes + 1, nodes + m + 1);
        int k = 1;//共k个不同的x坐标,组成了k-1个不同的区域
        for (int i = 2; i <= n; i++)
            if (X[i] != X[i - 1]) X[++k] = X[i];
        build(1, 1, k - 1);//少了build就WA
        double ret = 0.0;//最终面积
        for (int i = 1; i < m; i++) {
            int l = bin(nodes[i].l, k, X);
            int r = bin(nodes[i].r, k, X) - 1;
            if (l <= r) update(l, r, nodes[i].d, 1,1,k-1);
            ret += sum[1] * (nodes[i + 1].h - nodes[i].h);
        }
        printf("Test case #%d\nTotal explored area: %.2lf\n\n", ++T, ret);
    }
    return 0;
}