题目链接: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;
}