10.28 hdu1828 Picture（扫描线求周长）

题意：

求所有矩形重叠之后的并周长

解题思路：

扫描线模板题（但我还是wa了好多发）
我的思路是横着扫一遍，竖着扫一遍即可
注意：对边排序时，y坐标相同，入线排在出线的前面
   因为如果两个矩形的出线和入线重合，如果先出线后入线，会导致多算（因为这条入线本该被立即消掉）（我就是因为这个甚至怀疑模板问题…）

AC代码：

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
const int maxn = 2e5 + 10;
int v1[maxn], v2[maxn];
struct L1 {
    int x, y1, y2, state;
    bool operator < (L1 rhs) {
		if (x != rhs.x) return x < rhs.x; 
		else return state > rhs.state;
	}
} line1[maxn];
struct L2 {
    int y, x1, x2, state;
    bool operator < (L2 rhs) {
		if (y != rhs.y) return y < rhs.y;
		else return state > rhs.state;
	}
} line2[maxn];
struct Node {
    int l, r, cover;
    ll len;
} sgt1[maxn << 3], sgt2[maxn << 3]; //建了两颗线段树，其实一颗也可以，把数据重新统计即可
inline int ls(int k) {return k << 1;}
inline int rs(int k) {return k << 1 | 1;}
inline void pushup(int k, Node *sgt) {
    if (sgt[k].cover) sgt[k].len = sgt[k].r - sgt[k].l;
    else sgt[k].len = sgt[ls(k)].len + sgt[rs(k)].len;
}
void build(int l, int r, int rt, Node *sgt, int *v) {//传参数，就不用多开函数
    sgt[rt].l = v[l], sgt[rt].r = v[r];
    sgt[rt].len = sgt[rt].cover = 0;
    if (r - l <= 1) return;
    int mi = (l + r) >> 1;
    build(l, mi, ls(rt), sgt, v);
    build(mi, r, rs(rt), sgt, v);//注意这里是[mi, r]
}
void modify(int L, int R, int z, int rt, Node *sgt) {
    int l = sgt[rt].l, r = sgt[rt].r;
    if (L <= l && r <= R) {
        sgt[rt].cover += z;
        pushup(rt, sgt);
        return;
    }
    if (L < sgt[ls(rt)].r) modify(L, R, z, ls(rt), sgt);
    if (R > sgt[rs(rt)].l) modify(L, R, z, rs(rt), sgt);
    pushup(rt, sgt);
}
int main() {
    int a, b, c, d, n;
    while (cin >> n) {
        for (int i = 1; i <= n; i++) {
            cin >> a >> b >> c >> d;
            v1[i] = b, v1[i + n] = d;
            v2[i] = a, v2[i + n] = c;
            line1[i] = (L1) {a, b, d, 1}, line1[n + i] = (L1) {c, b, d, -1};
            line2[i] = (L2) {b, a, c, 1}, line2[n + i] = (L2) {d, a, c, -1};
        }
        sort (v1 + 1, v1 + 1 + (n << 1));
        sort (v2 + 1, v2 + 1 + (n << 1));
        sort (line1 + 1, line1 + 1 + (n << 1));
        sort (line2 + 1, line2 + 1 + (n << 1));
        build(1, n << 1, 1, sgt1, v1);
        build(1, n << 1, 1, sgt2, v2);
        ull ans = 0;
        ll pre = 0;
        for (int i = 1; i <= n << 1; i++) {
            ans += abs(sgt1[1].len - pre); //统计竖边
            pre = sgt1[1].len;
            modify(line1[i].y1, line1[i].y2, line1[i].state, 1, sgt1);
        }
        ans += abs(sgt1[1].len - pre);//这里也要加
        pre = 0;
        for (int i = 1; i <= n << 1; i++) {
            ans += abs(sgt2[1].len - pre);//统计横边
            pre = sgt2[1].len;
            modify(line2[i].x1, line2[i].x2, line2[i].state, 1, sgt2);
        }
        ans += abs(sgt2[1].len - pre);//这里也要加
        cout << ans << endl;        
    }

}