POJ 2528 – Mayor's posters
Advanced Data Structures :: Segment Tree
Description
在一个很长的墙上贴海报，每张海报的高度和墙一样高。
因此，墙和海报应该被看成线段。
输入即不停得往墙上贴海报。
输出最后墙上可以看到多少张海报（露出一部分也算）。
Type
Advanced Data Structures :: Segment Tree
Analysis
把墙和海报看成线段，让人容易想到线段树。
而贴海报的过程，正好是成段更新的过程。
但是，墙的长度最高可达10000000，这么大的区间无法用线段树。
不过我们发现，海报最多只有10000张，每个海报有左右坐标，那么顶多有20000个点。
可以离散化后，用线段树。（离散化具体内容见参考资料）
利用线段树模拟贴海报的过程，之后，为了统计有几张海报。
我们可以用哈希表，不过统计之前，记得将线段树的延迟标记全部更新到叶子。
不过这题存在一个bug。
从题目的这张图上，我们可以看出。
墙（被当作线段）上的“点”，并不是我们平常所想的没有长度的点。
它应该是一个个单位长度（题目所说的byte）。
因此，看两组数据。
有两张海报[1, 4] [5, 6]，他们就会覆盖[1, 6]这张海报。
另外两张海报[1, 3] [5, 6]，他们不会覆盖[1, 6]这张海报。
所以，如果我们常规离散化，两组数据的前两张海报都会变成[1, 2] [3, 4] [1, 4]，导致相同结果。
因此，在离散化时，注意处理这种某海报右坐标+1正好等于另一张海报左坐标的情况。
一种简单的办法是，如果海报是不相连的，那就在中间多加入一个数字，把两个坐标分隔开。
不过这样做，在POJ反而会WA。
可见POJ上的标程可能没有想到这一点，我们也只能委屈求全了。
Solution
// POJ 2528
// Mayor's posters
// by A Code Rabbit
#include <algorithm>
#include <cstdio>
#include <cstring>
using namespace std;
#define LSon(x) ((x) << 1)
#define RSon(x) ((x) << 1 | 1)
const int MAXN = 10002;
const int ROOT = 1;
struct Seg {
int w;
int flag;
};
struct SegTree {
Seg node[MAXN * 4 << 2];
void Build() { memset(node, 0, sizeof(node)); }
void Push(int pos) {
Seg& father = node[pos];
Seg& lson = node[LSon(pos)];
Seg& rson = node[RSon(pos)];
if (father.flag) {
lson.flag = rson.flag = father.flag;
lson.w = rson.w = father.flag;
father.flag = 0;
}
}
void Modify(int l, int r, int pos, int x, int y, int z) {
if (x <= l && r <= y) {
node[pos].w = z;
node[pos].flag = z;
return;
}
Push(pos);
int m = l + r >> 1;
if (x <= m) Modify(l, m, LSon(pos), x, y, z);
if (y > m) Modify(m + 1, r, RSon(pos), x, y, z);
}
void Query(int l, int r, int pos, bool* bo) {
if (l == r) {
bo[node[pos].w] = true;
return;
}
Push(pos);
int m = l + r >> 1;
Query(l, m, LSon(pos), bo);
Query(m + 1, r, RSon(pos), bo);
}
};
struct Poster {
int l, r;
};
int n;
Poster poster[MAXN];
int* pointer[MAXN << 2];
bool bo[MAXN];
SegTree tree;
bool CMP(int* x, int* y) {
return *x < *y;
}
int main() {
int tot_case;
scanf("%d", &tot_case);
while (tot_case--) {
// Input.
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d%d", &poster[i].l, &poster[i].r);
pointer[i * 2] = &poster[i].l;
pointer[i * 2 + 1] = &poster[i].r;
}
// Discretization.
sort(pointer, pointer + 2 * n, CMP);
int num_bytes = 1;
for (int i = 0; i < 2 * n - 1; i++) {
int tmp = num_bytes;
if (*pointer[i] != *pointer[i + 1]) {
if (*pointer[i] + 1 == *pointer[i + 1])
num_bytes += 1;
else
num_bytes += 1;
/* the correct answer should be: "num_bytes += 2;". */
}
*pointer[i] = tmp;
}
*pointer[2 * n - 1] = num_bytes;
// Stick posters by the segments tree.
tree.Build();
int num_posters = 1;
for (int i = 0; i < n; i++)
tree.Modify(1, num_bytes, ROOT, poster[i].l, poster[i].r, num_posters++);
// Compute and output.
memset(bo, false, sizeof(bo));
tree.Query(1, num_bytes, ROOT, bo);
int sum = 0;
for (int i = 0; i < num_posters; i++)
if (bo[i])
sum++;
printf("%d\n", sum);
}
return 0;
}