HDU 1828 Picture 【线段树+离散化+扫描线】

题目链接：http://acm.hdu.edu.cn/showproblem.php?pid=1828

题意要注意的是，周长不仅仅包括外周长，还包括内周长。

用扫描线从左向右扫一次，计算图形竖直部分的周长，用扫描线从下向上扫一次，计算图像横线部分的周长。

我们每次扫到一条边的时候，只取没和之前重叠的部分。类似这种求区间覆盖的问题，可以用线段树来解决，除此之外，我们还需要考虑把覆盖的区间还原回去。为什么？如果我们每次扫一条边就给这个区间覆盖一次，那么当遇到像题目样例那个图形的时候，最右边那两个矩形垂直的边就不会被计算到，因为这两个矩形的垂直边都被之前的矩形覆盖了。所以我们给每一个矩形定一个起始边和一个结束边，我们以垂直边为例，从左向右扫描，定一个矩形的左垂直边为起始边，右垂直边为结束边，当遇到起始边的时候就覆盖区间，遇到结束边的时候就还原区间，当扫描到最右边那两个矩形的时候，左边的矩形都被扫完，整个区间都被还原回去了，这时候再算最右边的矩形就不会出问题了。

在做这题的时候，遇到一个很棘手的问题。

不论是懒标记还是区间的结果，都需要满足可以合并的性质，比如说区间和可以通过左区间+右区间得到，区间加的时候，加的懒标记也是可以累加的。但是这个题目如果要用到覆盖的标记，就不存在这种可以合并的性质，比如说一个区间如果左区间被覆盖了一次，右区间被覆盖了两次，那么这个区间的覆盖标记又该是多少？

因为存在上面的那种问题，所以求区间长度的时候不能完全的依赖覆盖标记，但是覆盖标记还是有必要的。如何来做？

求没被覆盖的区间目前还想不到有效的求解方法，但是求被覆盖的区间还是有可能的。

能知道没被覆盖的区间是最好的，直接加起来就是答案了，知道被覆盖的区间我们同样也能求得到我们要的结果。

假设当前被覆盖的区间是0，扫描一条边之后，被覆盖的区间是 x ，扫描第二条边之后，被覆盖的区间是 y，abs(x - y)就是我们要求的没被覆盖的区间。（自己在草稿纸上演算一遍）

因为覆盖标记存在上面所说的那个问题，所以并不能完全依赖这个标记，我们还需要记录另一个数据，当前区间被覆盖的长度。

假设当前区间的覆盖标记是 0，但是左区间的覆盖标记是1，那么这个时候，当前区间的覆盖长度就是左区间加上右区间的被覆盖长度。当扫描一条能覆盖当前区间的边的时候，这个区间的覆盖标记就+1，那么这个时候的覆盖标记就是可信的，那么被覆盖的区间就是当前区间的整个区间长度，而不是左区间被覆盖长度+右区间被覆盖长度。当遇到结束边，当前区间的覆盖标记-1，这个时候的标记就为0，但并不能说明当前区间的覆盖区间长度就是0，而是依赖 (左区间被覆盖长度+右区间被覆盖长度) 这个结果。因为覆盖标记只有 > 0 时才是可信的，所以这种方法只能求被覆盖的区间长度，如果要求没被覆盖的区间长度，显然覆盖标记为0，根本说明不了这个区间一定没被覆盖。

上面的方法能很有效的解决覆盖标记不能合并的问题，因为这个标记可以不用向下传(pushdown)，有这个标记最好，没有也没啥所谓，访问左右区间就能得到结果。

最主要还是上面的方法，代码写的乱，有空再简化下：（离散化我就不多解释了）

#include <iostream>
#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <cmath>
#include <algorithm>
#include <set>

using namespace std;

#define lc (cur<<1)
#define rc ((cur<<1)|1)

const int Maxn = 5e3+10;
const int mod = 10007;

typedef long long ll;

struct tree {
    int cover, len;
} cSeg[Maxn<<3], rSeg[Maxn<<3];  // c是竖线(column), r是横线(row)

struct edge {
    int l, r, od, val; // od是排序规则，竖线的排序规则是x轴，横线的是y轴,
} cedge[Maxn<<1], redge[Maxn<<1]; // val == 1 是起始边 -1是结束边

int Hash[Maxn<<3], tmp[Maxn<<2], op, L, R;

bool cmp (const struct edge a1, const struct edge a2) {
    return a1.od < a2.od;
}

void pushup(int cur, int l, int r, tree * seg) {
    if(seg[cur].cover > 0) { // 如果这个区间有被覆盖，那么直接返回覆盖的长度,
        seg[cur].len = Hash[r]-Hash[l-1]; // 如果是0,说明这个区间没有整块被覆盖，但是仍然有可能存在
    } else if(r == l) {                    // 被覆盖的小区间，这时要通过访问子节点来知道有多少长度的
        seg[cur].len = 0;                   // 区间被覆盖了。这里要注意叶结点，如果当前是叶结点，就直接
    } else {                                   // 返回叶结点被覆盖的长度。
        seg[cur].len = seg[lc].len+seg[rc].len;
    }
}

void updata(int cur, int l, int r, tree * seg) {
    if(L <= l && r <= R) {
        seg[cur].cover += op;
        pushup(cur, l, r, seg);
        return;
    }

    int mid = (r+l)>>1;

    if(L <= mid) updata(lc, l, mid, seg);
    if(mid+1 <= R) updata(rc, mid+1, r, seg);

    pushup(cur, l, r, seg);
}

int main(void)
{
    int N;
    while (scanf("%d", &N) != EOF) {
        for(int i = 0; i < N*4; ++i) {
            scanf("%d", &tmp[i]);
            Hash[i] = tmp[i];
        }

        sort(Hash, Hash+4*N);
        int len = unique(Hash, Hash+4*N)-Hash;  // 离散化
        int lx, rx, ly, ry, sizec = 0, sizer = 0, m = 1;
        for(int i = 0; i < N; ++i) {
            lx = lower_bound(Hash, Hash+len, tmp[(i<<2)])-Hash+1;
            rx = lower_bound(Hash, Hash+len, tmp[(i<<2)+2])-Hash;
            ly = lower_bound(Hash, Hash+len, tmp[(i<<2)+1])-Hash+1;
            ry = lower_bound(Hash, Hash+len, tmp[(i<<2)+3])-Hash;

            cedge[m].l = cedge[m+1].l = ly;
            cedge[m].r = cedge[m+1].r = ry;
            redge[m].l = redge[m+1].l = lx;
            redge[m].r = redge[m+1].r = rx;
            cedge[m].od = tmp[(i<<2)]; cedge[m+1].od = tmp[(i<<2)+2];
            redge[m].od = tmp[(i<<2)+1]; redge[m+1].od = tmp[(i<<2)+3];
            cedge[m].val= redge[m].val = 1;
            cedge[m+1].val = redge[m+1].val = -1;

            sizec = max(sizec, ry); sizer = max(sizer, rx);
            m += 2;
        }
        sort(cedge+1, cedge+m, cmp); sort(redge+1, redge+m, cmp);

        // 初始化
        for(int i = 0; i <= 4*sizec; ++i) cSeg[i].cover = cSeg[i].len = 0;
        for(int i = 0; i <= 4*sizer; ++i) rSeg[i].cover = rSeg[i].len = 0;

        int last = 0, ans1 = 0, ans2 = 0;

        for(int i = 1; i < m; ++i) {
            L = cedge[i].l; R = cedge[i].r;
            op = cedge[i].val;
            updata(1, 1, sizec, cSeg);
            ans1 += abs(last-cSeg[1].len);
            last = cSeg[1].len;
        }
        last = 0;
        for(int i = 1; i < m; ++i) {
            L = redge[i].l; R = redge[i].r;
            op = redge[i].val;
            updata(1, 1, sizer, rSeg);
            ans2 += abs(last-rSeg[1].len);
            last = rSeg[1].len;
        }
        printf("%d\n", ans1+ans2);
    }
    return 0;
}