acwing 247 亚特兰蒂斯

https://www.acwing.com/problem/content/249/

有几个古希腊书籍中包含了对传说中的亚特兰蒂斯岛的描述。
其中一些甚至包括岛屿部分地图。
但不幸的是，这些地图描述了亚特兰蒂斯的不同区域。
您的朋友 Bill 必须知道地图的总面积。
你自告奋勇写了一个计算这个总面积的程序。

输入格式
输入包含多组测试用例。

对于每组测试用例，第一行包含整数 n，表示总的地图数量。

接下来 n 行，描绘了每张地图，每行包含四个数字 x1,y1,x2,y2（不一定是整数），
(x1,y1)和 (x2,y2)分别是地图的左上角位置和右下角位置。

注意，坐标轴 x 轴从上向下延伸，y 轴从左向右延伸。

当输入用例 n=0时，表示输入终止，该用例无需处理。

输出格式
每组测试用例输出两行。

第一行输出 Test case #k，其中 k是测试用例的编号，从 1 开始。

第二行输出 Total explored area: a，其中 a是总地图面积
（即此测试用例中所有矩形的面积并，注意如果一片区域被多个地图包含，则在计算总面积时只计算一次），精确到小数点后两位数。

在每个测试用例后输出一个空行。

数据范围
1≤n≤10000
,
0≤x1<x2≤100000
,
0≤y1<y2≤100000

注意，本题 n的范围上限加强至 10000

输入样例：
2
10 10 20 20
15 15 25 25.5
0
输出样例：
Test case #1
Total explored area: 180.00 

扫描线 线段树

#define _CRT_SECURE_NO_WARNINGS
#include <cstdio>
#include <cstring>
#include <iostream>
#include <algorithm>
#include <vector>

using namespace std;


const int N = 100010;
int n, m;
struct Segment {
    double x, y1, y2;
    int k;
    bool operator <(const Segment& t) const {
        return x < t.x;
    };
}seg[N * 2];

struct Node {
    int l, r;
    int cnt;
    double len;
}tr[N * 8];

vector<double> ys;

int find(double y) {
    int ret = lower_bound(ys.begin(), ys.end(), y) - ys.begin();
    return ret;
}

void build(int u, int l, int r) {
    tr[u] = { l,r,0,0 };
    if (l != r) {
        int mid = l + r >> 1;
        build(u<<1, l, mid); build(u << 1 | 1, mid + 1, r);
    }
}

void pushup(int u) {
    if (tr[u].cnt) tr[u].len = ys[(tr[u].r) + 1] - ys[(tr[u].l)];
    else
        tr[u].len = tr[u << 1].len + tr[u << 1 | 1].len;
}


void modify(int u, int l, int r, int k) {
    if (l <= tr[u].l && r >= tr[u].r) {
        tr[u].cnt += k;
        pushup(u);
    }
    else {
        int mid = tr[u].l + tr[u].r >> 1;
        if (l <= mid) modify(u << 1, l, r, k);
        if (r > mid) modify(u << 1 | 1, l, r, k);
        pushup(u);
    }
}

int main() {
    int T = 1;
    while (scanf("%d", &n), n) {
        ys.clear(); ys.push_back(-1);
        int idx = 1;
        for (int i = 1; i <= n; i++) {
            double x1, y1, x2, y2; scanf("%lf%lf%lf%lf", &x1, &y1, &x2, &y2);
            ys.push_back(y1); ys.push_back(y2);
            seg[idx++] = { x1,y1,y2,1 };
            seg[idx++] = { x2,y1,y2,-1 };
        }
        sort(seg + 1, seg + idx);
        sort(ys.begin(), ys.end());
        ys.erase(unique(ys.begin(), ys.end()), ys.end());
        m = ys.size() - 1;

        build(1, 1, m);

        double res = 0;
        for (int i = 1; i < idx; i++) {
            res += tr[1].len * (seg[i].x - seg[i - 1].x);
            modify(1, find(seg[i].y1), find(seg[i].y2) - 1, seg[i].k);
        }

        printf("Test case #%d\n",T++);
        printf("Total explored area: %.2lf\n\n",res);
    }
   


    return 0;
}

第二种带pushdown的方法

#define _CRT_SECURE_NO_WARNINGS
//https://www.acwing.com/problem/content/249/
#include <cstdio>
#include <cstring>
#include <iostream>
#include <algorithm>
#include <vector>

using namespace std;

const int N = 20010;
vector<double> ys;

struct NODE {
	int l, r, mincnt;
	int lazy;
	double len;
}tr[N*4];

struct Segment {
    double x, y1, y2;
    int k;
    bool operator <(const Segment& t) const {
        return x < t.x;
    };
}seg[N];
int n, m;

int find(double y) {
    int ret = lower_bound(ys.begin(), ys.end(), y) - ys.begin();
    return ret;
}


void pushup(int u) {
    tr[u].mincnt = min(tr[u << 1].mincnt, tr[u << 1 | 1].mincnt);
    if (tr[u << 1].mincnt == tr[u << 1 | 1].mincnt) {
        tr[u].len = tr[u << 1].len + tr[u << 1 | 1].len;
    }
    else if (tr[u << 1].mincnt < tr[u << 1 | 1].mincnt) {
        tr[u].len = tr[u << 1].len;
    }
    else {
        tr[u].len = tr[u << 1|1].len;
    }
}


void build(int u, int l, int r) {
    tr[u] = { l,r,0,0,0 };
    if (l == r) {
        tr[u].len = ys[l + 1] - ys[l];
    }
    else {
        int mid = l + r >> 1;
        build(u << 1, l, mid);
        build(u << 1 | 1, mid + 1, r);
        pushup(u);
        //tr[u].len = ys[r + 1] - ys[l];
    }

}

void pushdown(int u) {
    int k = tr[u].lazy;
    if (k) {
        tr[u << 1].mincnt = tr[u << 1].mincnt + k;
        tr[u << 1].lazy = tr[u << 1].lazy + k;
        tr[u << 1 | 1].mincnt = tr[u << 1 | 1].mincnt + k;
        tr[u << 1 | 1].lazy = tr[u << 1 | 1].lazy + k;
        tr[u].lazy = 0;
    }
}

void modify(int u, int l, int r, int k) {
    if (l <= tr[u].l && r >= tr[u].r) {
        tr[u].mincnt += k;
        tr[u].lazy += k;
    }
    else {
        int mid = tr[u].l + tr[u].r >> 1;
        pushdown(u);
        if (l <= mid) modify(u << 1, l, r, k);
        if (r > mid) modify(u << 1 | 1, l, r, k);
        pushup(u);
    }
}

int main() {
    int T = 1;
    while (scanf("%d", &n), n) {
        ys.clear(); ys.push_back(-1);
        int idx = 1;
        for (int i = 1; i <= n; i++) {
            double x1, y1, x2, y2;
            scanf("%lf%lf%lf%lf",&x1,&y1,&x2,&y2);
            ys.push_back(y1); ys.push_back(y2);
            seg[idx++] = { x1,y1,y2,1 };
            seg[idx++] = { x2,y1,y2,-1 };
        }

        sort(ys.begin(), ys.end());
        sort(seg + 1, seg + idx);
        ys.erase(unique(ys.begin(), ys.end()), ys.end());
        m = ys.size() - 2;
        build(1, 1, m);

        double res = 0;
        double totallen = tr[1].len;
        double prex = 0;
        for (int i = 1; i < idx; i++) {
            double cov = totallen;
            if (tr[1].mincnt == 0) {
                cov = totallen - tr[1].len;
            }
            res += cov * (seg[i].x - prex);
            prex = seg[i].x;
            int y1 = find(seg[i].y1);
            int y2 = find(seg[i].y2)-1;
            modify(1, y1, y2, seg[i].k);
        }

        printf("Test case #%d\n",T++);
        printf("Total explored area: %.2lf\n\n", res);

    }

    return 0;
}

我的视频题解空间