HDU 1542 Atlantis（扫描线算法）

#include<iostream>
#include<cstdio>
#include<algorithm>
#include<cstring>
#include<vector>
using namespace std;

const int Maxn = 500;

struct Edge {//平行于y轴的边
    double l, r;//边所覆盖区间
    double x;//边在x轴上的坐标
    int d;//该值为1或-1，表示入边或出边

    Edge(double l, double r, double x, int d) : l(l), r(r), x(x), d(d) {}

    bool operator < (const Edge& B) const {
        return x < B.x;
    }
};

struct Node { //线段树的结点
    int l, r; //结点所管辖区间
    int res; //区间被直接完全覆盖次数
    double len; //结点所管辖区间的有效覆盖长度
};

vector<double> x;
vector<double> y;

vector<Edge> e;
Node Tree[Maxn << 2];

int getX(double X)
{
    return lower_bound(x.begin(), x.end(), X) - x.begin();
}

int getY(double Y)
{
    return lower_bound(y.begin(), y.end(), Y) - y.begin();
}

inline int lc(int p) {
    return p << 1;
}

inline int rc(int p) {
    return p << 1 | 1;
}

void push_up(int p)
{
    if (Tree[p].res > 0) Tree[p].len = Tree[p].len = y[Tree[p].r] - y[Tree[p].l]; //该区间线段已被直接覆盖，直接取其有效长度
    else if (Tree[p].l + 1 == Tree[p].r) Tree[p].len = 0; //是叶子节点，则其有效长度为0
    else Tree[p].len = Tree[lc(p)].len + Tree[rc(p)].len;//不是被直接覆盖，就从子节点提取有效长度值
}

void Build_Tree(int l, int r, int p)
{
    Tree[p].l = l;
    Tree[p].r = r;

    if (l + 1 == r) return;

    int m = l + r >> 1;
    Build_Tree(l, m, lc(p));
    Build_Tree(m, r, rc(p));
}

void update(int L, int R, int p, int d)
{
    if (Tree[p].r <= L || Tree[p].l >= R) return;
    if (L <= Tree[p].l && Tree[p].r <= R) {
        Tree[p].res += d;
        push_up(p);
        return;
    }

    update(L, R, lc(p), d);
    update(L, R, rc(p), d);
    push_up(p);
}

double Query()
{
    return Tree[1].len;
}

void Test()
{
    for (int i = 1; i < y.size(); i++) {
        printf("%d: %f\n", i, y[i]);
    }
}

void Ini()
{
    e.clear();
    x.clear();
    y.clear();
    memset(Tree, 0, sizeof(Tree));
}

void Input(int n)
{
    x.push_back(-1); //使离散化的下标从1开始，喜欢从0开始的同学可以忽略
    y.push_back(-1);
    for (int i = 1; i <= n; i++) {
        double x1, y1, x2, y2;
        cin >> x1 >> y1 >> x2 >> y2;
        x.push_back(x1);
        x.push_back(x2);
        y.push_back(y1);
        y.push_back(y2);

        e.push_back(Edge(y1, y2, x1, 1));
        e.push_back(Edge(y1, y2, x2, -1));
    }
    e.push_back(Edge(0, 0, 100000 + 10, 0));//末尾添加个0值边，方便循环处理
}

void solve(int Case)
{
    cout << "Test case #" << Case << endl;
    sort(x.begin(), x.end());
    sort(y.begin(), y.end());
    sort(e.begin(), e.end());

    x.erase(unique(x.begin(), x.end()), x.end());
    y.erase(unique(y.begin(), y.end()), y.end());

    Build_Tree(1, y.size() - 1, 1);

    double ans = 0;
    int cur = 0;
    for (int i = 1; i < x.size()-1; i++) {
        while (e[cur].x == x[i]) {
            update(getY(e[cur].l), getY(e[cur].r), 1, e[cur].d);
            cur++;
        }

        ans += Query() * (x[i + 1] - x[i]);
    }

    printf("Total explored area: %.2f\n", ans);
}

int main()
{
    int Case = 0;
    int n;
    while (cin >> n && n) {
        Case++;
        Ini();
        Input(n);
        solve(Case);
        cout << endl;
    }

    return 0;
}