【离散化 && 线段树 && 染色】POJ - 2528 Mayor's posters

Problem Description

给你T组测试数据，每组测试数据输入n，代表有n行，接下来每行输入ul, ur代表海报贴的区间覆盖是ul-ur。问你贴完后能看到多少张海报。

Sample Input

1

5

1 4

2 6

8 10

3 4

7 10

Sample Output

4

思路：

因为给你的海报贴的区间范围有点大，如果直接开线段树肯定爆内存。所以我们先离散化一下，因为1<=n<=10000，所以最多有2*n个不同的点。我们就将区间压缩，如果压缩呢？例如样例：我们将所有点排序取重得到

1 2 3 4 6 7 8 10 让它们分别对应1 2 3 4 5 6 7 8这样最大原本是10，压缩到了8。区间1->4, 2->6, 8->10, 3->4, 7->10对应就变为1->4, 2->5, 7->8, 3->4, 6->8。这样的结果得到的结果是不会改变的。接下来就是如何处理贴海报，我们倒着贴题目就变得非常简单了，判断区间是否贴满，没有贴满ans++。贴满了，你在贴也就是被覆盖了。

#include<cstdio>
#include<algorithm>
using namespace std;
#define lson root << 1
#define rson root << 1 | 1
#define MID int mid = (l + r) / 2
#define N 20005
struct node
{
int lazy;
int sum;//没贴过的地方为0，贴过的为1
};
node tree[4 * N];
int a
[2], data[2 * N];
node merge_(node x, node y)
{
node t;
t.lazy = 0;
t.sum = x.sum + y.sum;
return t;
}
void build(int root, int l, int r)
{
tree[root].lazy = 0;
if(l == r)
{
tree[root].sum = 0;
return;
}
MID;
build(lson, l, mid);
build(rson, mid + 1, r);
tree[root] = merge_(tree[lson], tree[rson]);
}
void pushdown(int root, int l, int r)
{
if(tree[root].lazy)
{
MID;
tree[lson].lazy = tree[rson].lazy = tree[root].lazy;
tree[lson].sum = (mid - l + 1) * tree[lson].lazy;
tree[rson].sum = (r - (mid + 1) + 1) * tree[rson].lazy;
tree[root].lazy = 0;
}
}
int query(int root, int l, int r, int ul, int ur)//求区间ul-ur的和
{
if(ul <= l && r <= ur)
{
return tree[root].sum;
}
pushdown(root, l, r);
int red = 0;
MID;
if(ul <= mid) red += query(lson, l, mid, ul, ur);
if(ur > mid) red += query(rson, mid + 1, r, ul, ur);
return red;
}
void updata(int root, int l, int r, int ul, int ur, int v)//更新ul-ur的区间为1
{
if(ul <= l && r <= ur)
{
tree[root].lazy = v;
tree[root].sum = (r - l + 1) * v;
return;
}
pushdown(root, l, r);
MID;
if(ul <= mid) updata(lson, l, mid, ul, ur, v);
if(ur > mid) updata(rson, mid + 1, r, ul, ur, v);
tree[root] = merge_(tree[lson], tree[rson]);
}
int main()
{
int T, n, i;
scanf("%d", &T);
while(T--)
{
scanf("%d", &n);
int top = 1;
for(i = 1; i <= n; i++)
{
scanf("%d %d", &a[i][0], &a[i][1]);//将点存起来
data[top++] = a[i][0];
data[top++] = a[i][1];
}
sort(data + 1, data + top);//排序
top = unique(data + 1, data + top) - data;//去重
build(1, 1, top);//初始化建树
int cnt = 0;
for(i = n; i >= 0; i--)
{
int ul = lower_bound(data + 1, data + top, a[i][0]) - data;//取离散化后的左区间
int ur = lower_bound(data + 1, data + top, a[i][1]) - data;//取离散化后的右区间
int ans = query(1, 1, top, ul, ur);
if(ans != ur - ul + 1) cnt++;//代表区间ul-ur没有贴满
updata(1, 1, top, ul, ur, 1);//更新
}
printf("%d\n", cnt);
}
}