【线段树 + 离散化 + 扫描线】poj 1151 Atlantis 矩形面积并

将所有的线段按照x左边从小到大排序，并对所有的横纵坐标进行离散化，从左到右扫描，每碰到一条矩形左侧的线段，就插入线段树；每碰到一条矩形右侧的线段，就从线段树中删除。同时线段树中每个节点要维护一个计数变量，应对一个区间被多个矩形覆盖的情形。

#include <vector>
#include <list>
#include <limits.h>
#include <map>
#include <set>
#include <deque>
#include <queue>
#include <stack>
#include <bitset>
#include <algorithm>
#include <functional>
#include <numeric>
#include <utility>
#include <sstream>
#include <iostream>
#include <iomanip>
#include <cstdio>
#include <cmath>
#include <cstdlib>
#include <ctime>
#include <string.h>
#include <stdlib.h>
#include <cassert>
using namespace std;

struct Node {
double total;
int left, right, lc, rc, cnt;
Node() {
total = cnt = 0;
left = right = lc = rc = -1;
}
};
Node tree[1500];

struct Line {
double x, y1, y2;
bool left;
Line(double _x, double _y1, double _y2, bool _left): x(_x), y1(_y1), y2(_y2), left(_left) {}
};

bool cmp(const Line& i, const Line& j) { return i.x < j.x; }

int n, ptr;
vector<Line> lines;
vector<double> ys;

int get(double y) {
for (int i = 0; i < ys.size(); ++i) {
if (fabs(y - ys[i]) < 1e-6) return i;
}
assert(false); // should not reach here
return -1;
}

void build_tree(int low, int up, int cur) {
tree[cur].left = low;
tree[cur].right = up;
if (up - low <= 1) return;
int mid = (low + up) / 2;
++ptr; tree[cur].lc = ptr;
build_tree(low, mid, ptr);
++ptr; tree[cur].rc = ptr;
build_tree(mid, up, ptr);
return;
}

void update_node(int root) {
if (tree[root].cnt > 0) {
tree[root].total = ys[tree[root].right] - ys[tree[root].left];
return;
}
if (tree[root].right - tree[root].left <= 1) {
tree[root].total = 0;
return;
}
else {
tree[root].total = tree[tree[root].lc].total + tree[tree[root].rc].total;
return;
}
}

void insert_node(int low, int up, int cur) {
// cout << "insert: " << low << " " << up << " " << cur << endl;
if (low <= tree[cur].left && up >= tree[cur].right) {
++tree[cur].cnt;
update_node(cur);
return;
}
assert(tree[cur].right - tree[cur].left > 1);
int mid = (tree[cur].left + tree[cur].right) / 2;
if (up <= mid) { insert_node(low, up, tree[cur].lc); }
else if (low >= mid) { insert_node(low, up, tree[cur].rc); }
else {
insert_node(low, mid, tree[cur].lc);
insert_node(mid, up, tree[cur].rc);
}
update_node(cur);
return;
}

void delete_node(int low, int up, int cur) {
if (low <= tree[cur].left && up >= tree[cur].right) {
assert(tree[cur].cnt > 0);
--tree[cur].cnt;
update_node(cur);
return;
}
assert(tree[cur].right - tree[cur].left > 1);
int mid = (tree[cur].left + tree[cur].right) / 2;
if (up <= mid) { delete_node(low, up, tree[cur].lc); }
else if (low >= mid) { delete_node(low, up, tree[cur].rc); }
else {
delete_node(low, mid, tree[cur].lc);
delete_node(mid, up, tree[cur].rc);
}
update_node(cur);
return;
}

int main() {
int t = 1;
while (cin >> n && n) {
double x1, y1, x2, y2;
lines.clear(); ys.clear(); ptr = 0;
for (int i = 0; i < 1500; ++i) {
tree[i].total = tree[i].cnt = 0;
tree[i].left = tree[i].right = tree[i].lc = tree[i].rc = -1;
}
for (int i = 0; i < n; ++i) {
cin >> x1 >> y1 >> x2 >> y2;
lines.push_back(Line(x1, y1, y2, true));
lines.push_back(Line(x2, y1, y2, false));
ys.push_back(y1); ys.push_back(y2);
}
sort(lines.begin(), lines.end(), cmp);
sort(ys.begin(), ys.end());
double area = 0;
build_tree(0, ys.size(), 0);
for (int i = 0; i + 1 < lines.size(); ++i) {
Line tmp = lines[i];
if (tmp.left) insert_node(get(tmp.y1), get(tmp.y2), 0);
else delete_node(get(tmp.y1), get(tmp.y2), 0);
area += tree[0].total * (lines[i + 1].x - tmp.x);
}
cout << "Test case #" << t++ << endl;
cout << "Total explored area: " << fixed << setprecision(2) << area << endl;
cout << endl;
}
return 0;
}