1
// 离散化后 M 段，cnt[i] 记录第 i 段被几个矩形覆盖
2
vector<int> cnt(M + 1, 0);
3
vector<int> len(M + 1);
4
for (int i = 1; i <= M; i++) len[i] = ys[i] - ys[i-1];
5

6
for (auto& e : events) {
7
    // 1. 先算面积
8
    long long cover = 0;
9
    for (int i = 1; i <= M; i++)
10
        if (cnt[i] > 0) cover += len[i];
11
    ans += (e.x - last_x) * cover;
12

13
    // 2. 再更新 cnt
14
    for (int i = e.yl; i < e.yr; i++)
15
        cnt[i] += e.type;
16

17
    last_x = e.x;
18
}

1
#include <bits/stdc++.h>
2
using namespace std;
3

4
struct Node {
5
    int cnt, len, total;
6
} tr[800010];
7

8
struct Event {
9
    int x, type, yl, yr;
10
    bool operator<(const Event& e) const { return x < e.x; }
11
};
12

13
vector<int> ys;
14
int M;
15

16
void build(int u, int l, int r) {
17
    if (l == r) { tr[u].total = ys[l+1] - ys[l]; return; }
18
    int mid = (l + r) >> 1;
19
    build(u<<1, l, mid);
20
    build(u<<1|1, mid+1, r);
21
    tr[u].total = tr[u<<1].total + tr[u<<1|1].total;
22
}
23

24
void push_up(int u, int l, int r) {
25
    if (tr[u].cnt > 0) tr[u].len = tr[u].total;
26
    else if (l == r) tr[u].len = 0;
27
    else tr[u].len = tr[u<<1].len + tr[u<<1|1].len;
28
}
29

30
void update(int u, int l, int r, int ql, int qr, int type) {
31
    if (ql <= l && r <= qr) {
32
        tr[u].cnt += type;
33
        push_up(u, l, r);
34
        return;
35
    }
36
    int mid = (l + r) >> 1;
37
    if (ql <= mid) update(u<<1, l, mid, ql, qr, type);
38
    if (qr > mid)  update(u<<1|1, mid+1, r, ql, qr, type);
39
    push_up(u, l, r);
40
}
41

42
int main() {
43
    int n; cin >> n;
44
    vector<Event> events;
45
    for (int i = 0; i < n; i++) {
46
        int x1, y1, x2, y2;
47
        cin >> x1 >> y1 >> x2 >> y2;
48
        ys.push_back(y1); ys.push_back(y2);
49
        events.push_back({x1, +1, y1, y2});
50
        events.push_back({x2, -1, y1, y2});
51
    }
52

53
    // 离散化
54
    sort(ys.begin(), ys.end());
55
    ys.erase(unique(ys.begin(), ys.end()), ys.end());
56
    M = ys.size() - 1;
57
    auto get_id = [&](int y) {
58
        return lower_bound(ys.begin(), ys.end(), y) - ys.begin();
59
    };
60
    for (auto& e : events) { e.yl = get_id(e.yl); e.yr = get_id(e.yr); }
61
    sort(events.begin(), events.end());
62

63
    build(1, 0, M - 1);
64
    long long ans = 0, last_x = 0;
65
    for (auto& e : events) {
66
        ans += (long long)(e.x - last_x) * tr[1].len;
67
        update(1, 0, M - 1, e.yl, e.yr - 1, e.type);
68
        last_x = e.x;
69
    }
70
    cout << ans << endl;
71
    return 0;
72
}

1
#include <bits/stdc++.h>
2
using namespace std;
3

4
int n, a, b, c;
5
struct node {
6
    int x1[100005], x2[100005];
7
} p[3];
8

9
bool cmp(pair<int,int>& u, pair<int,int>& v) {
10
    if (u.first != v.first) return u.first < v.first;
11
    return u.second > v.second;  // +1 在前，-1 在后
12
}
13

14
int getmax(node *arr) {
15
    vector<pair<int, int>> s;
16
    for (int i = 1; i <= n; i++) {
17
        if (arr->x1[i] > arr->x2[i]) swap(arr->x1[i], arr->x2[i]);
18
        s.push_back({arr->x1[i], 1});
19
        s.push_back({arr->x2[i], -1});
20
    }
21
    sort(s.begin(), s.end(), cmp);
22
    int cnt = 0, maxn = 0;
23
    for (auto [pos, type] : s) {
24
        cnt += type;
25
        maxn = max(maxn, cnt);
26
    }
27
    return maxn;
28
}
29

30
int main() {
31
    cin >> n >> a >> b >> c;
32
    for (int i = 1; i <= n; i++) {
33
        // 每行：x1 y1 z1 x2 y2 z2
34
        cin >> p[0].x1[i] >> p[1].x1[i] >> p[2].x1[i]
35
            >> p[0].x2[i] >> p[1].x2[i] >> p[2].x2[i];
36
    }
37
    // p[0] 存所有线段的 x 坐标，p[1] 存 y，p[2] 存 z
38
    int ans = max({getmax(&p[0]), getmax(&p[1]), getmax(&p[2])});
39
    cout << ans;
40
    return 0;
41
}