POJ 2528 Mayor's posters 线段树+离散化
题目链接 http://poj.org/problem?id=2528
题意: 有长度为 10000000 的一堵墙, n个市长按照先后顺序在 L 到 R 区间之间张贴海报,问最后能看见几个人的海报, 后面的海报会覆盖掉前面的海报.
先了解一下离散化吧(传送门):
有些数据本身很大， 自身无法作为数组的下标保存对应的属性。
如果这时只是需要这堆数据的相对属性， 那么可以对其进行离散化处理！
离散化：当数据只与它们之间的相对大小有关，而与具体是多少无关时，可以进行离散化。
例如
9 1 0 5 4 与 5 2 1 4 3 的逆序对个数相同。
设有4个数：
1234567、123456789、12345678、123456
排序：123456<1234567<12345678<123456789
=> 1 < 2 < 3 < 4
那么这4个数可以表示成：2、4、3、1
使用STL算法离散化：
思路：先排序，再删除重复元素，然后就是索引元素离散化后对应的值。
假定待离散化的序列为a[n]，b[n]是序列a[n]的一个副本，则对应以上三步为：
<pre name="code" class="sh_cpp sh_sourceCode" style="background-color:white; font-size:16px; font-family:'Courier New',Courier,monospace"><span class="sh_function" style="font-weight:bold">sort</span><span class="sh_symbol" style="color:#8b00;">(</span>sub_a<span class="sh_symbol" style="color:#8b00;">,</span>sub_a<span class="sh_symbol" style="color:#8b00;">+</span>n<span class="sh_symbol" style="color:#8b00;">);</span>
<span class="sh_type" style="color:#0640;">int</span> size<span class="sh_symbol" style="color:#8b00;">=</span><span class="sh_function" style="font-weight:bold">unique</span><span class="sh_symbol" style="color:#8b00;">(</span>sub_a<span class="sh_symbol" style="color:#8b00;">,</span>sub_a<span class="sh_symbol" style="color:#8b00;">+</span>n<span class="sh_symbol" style="color:#8b00;">)-</span>sub_a<span class="sh_symbol" style="color:#8b00;">;</span><span style="font-family:Georgia,'Bitstream Charter',serif;font-size:16px">//size为离散化后元素个数</span>
<span class="sh_keyword" style="color:blue;font-weight:bold">for</span><span class="sh_symbol" style="color:#8b00;">(</span>i<span class="sh_symbol" style="color:#8b00;">=</span><span class="sh_number" style="color:purple;">0</span><span class="sh_symbol" style="color:#8b00;">;</span>i<span class="sh_symbol" style="color:#8b00;"><</span>n<span class="sh_symbol" style="color:#8b00;">;</span>i<span class="sh_symbol" style="color:#8b00;">++)</span>a [i ]= lower_bound (sub_a ,sub_a +size ,a [i ])-sub_a + 1 ; //k为b[i]经离散化后对应的值
对于第3步，若离散化后序列为0, 1, 2, ..., size - 1则用lower_bound，从1, 2, 3, ..., size则用upper_bound，其中lower_bound返回第1个不小于b[i]的值的指针，而upper_bound返回第1个大于b[i]的值的指针，当然在这个题中也可以用lower_bound然后再加1得到与upper_bound相同结果，两者都是针对以排好序列。使用STL离散化大大减少了代码量且结构相当清晰。
解题思路:
观察 墙的长度 是 10000000, 询问是有 10000 个, 每次询问有两个节点,也就是有10000 * 2个节点,如果按长度建立线段树, 会MLE(试过了~~~~(>_<)~~~~ ),所以应该按照节点数建立线段树, 但是要把节点离散化,建立一个映射关系. 因为节点的大小是在 10000000 以内的.
线段树的区间更新和查询;
先把这 2 * n 个节点 按照 从小到大顺序 排序, 建立映射, 在 更新树 更新的节点 是映射之后的小区间的节点.
方案一: 对 falg 数组排序,下面在通过 二分查找, 找到 这个结点在 已排好序的flag数组的下标, 这个下标就是他的映射;
方案二: 用 hash 数组 存下标,不用查找了,但是这个方法即浪费内存,也耗时,没有二分快.------------当然还有其他很多方法,比如map等等
代码1 1176K 235MS
#include <stdio.h>
#include <string.h>
#include <algorithm>
using namespace std;
#define maxm 20005
struct Tree
{
int left, right, num;
}node[maxm << 2];
struct A
{
int l, r;
}a[maxm];
int hash[maxm], ans = 0, flag[maxm];
void BuildTree(int i, int l, int r);
void Update(int i, int num, int l, int r);
void PushDown(int i);
void Query(int i);
int Find(int num , int l , int r);
int main()
{
int t, n, i, j, x, y;
scanf("%d", &t);
while(t--)
{
scanf("%d", &n);
for(i = 1; i <= n; i++)
{
scanf("%d %d", &a[i].l, &a[i].r);
flag[2*i-1] = a[i].l , flag[2*i] = a[i].r;
}
sort(flag + 1 , flag + 2*n + 1);
BuildTree(1, 1, maxm);
for(i = 1; i <= n; i++)
{
x = Find(a[i].l , 1 , 2*n);
y = Find(a[i].r , 1 , 2*n);
Update(1, i, x, y);
}
memset(hash, 0, sizeof(hash));
ans = 0;
Query(1);
printf("%d\n", ans);
}
}
void BuildTree(int i, int l, int r)
{
node[i].left = l;
node[i].right = r;
node[i].num = 0;
if(l == r) return;
int mid = (l + r) >> 1;
BuildTree(i << 1, l, mid);
BuildTree(i << 1 | 1, mid + 1, r);
}
void Update(int i, int num, int l, int r)
{
if(node[i].left == l && node[i].right == r)
{
node[i].num = num;
return;
}
if(node[i].num != -1)
{
PushDown(i);
node[i].num = -1;
}
int mid = (node[i].left + node[i].right) >> 1;
if(r <= mid) Update(i << 1, num, l, r);
else if(l > mid) Update(i << 1 | 1, num, l, r);
else
{
Update(i << 1, num, l, mid);
Update(i << 1 | 1, num, mid + 1, r);
}
}
void PushDown(int i)
{
node[i << 1].num = node[i << 1 | 1].num = node[i].num;
}
void Query(int i)
{
if(node[i].num != -1)
{
if(node[i].num > 0 && hash[node[i].num] == 0)
{
hash[node[i].num] = 1;
ans++;
}
return;
}
else
{
Query(i << 1);
Query(i << 1 | 1);
}
}
int Find(int num , int l , int r)
{
if(l > r) return 0;
int mid = (l + r) >> 1;
if(flag[mid] == num)
{
int i = mid - 1;
for( ; i > 0 ; --i)
{
if(flag[i] != num) break;
}
return i + 1;
}
if(flag[mid] < num) return Find(num , mid + 1 , r);
else return Find(num , l , mid - 1);
}
代码2: 40272K 625MS
#include <stdio.h>
#include <string.h>
#include <algorithm>
using namespace std;
#define maxn 10000005
#define maxm 20005
struct Tree
{
int left, right, num;
}node[maxm << 2];
struct A
{
int l, r;
}a[maxm];
int hash[maxn], ans = 0, flag[maxm];
void BuildTree(int i, int l, int r);
void Update(int i, int num, int l, int r);
void PushDown(int i);
void Query(int i);
int main()
{
int t, n, i, j, x, y;
scanf("%d", &t);
while(t--)
{
scanf("%d", &n);
for(i = 1; i <= n; i++)
{
scanf("%d %d", &a[i].l, &a[i].r);
flag[2*i-1] = a[i].l , flag[2*i] = a[i].r;
}
sort(flag + 1 , flag + 2*n + 1);
j = 1;
memset(hash, 0, sizeof(hash));
for(i = 1; i <= 2 * n; i++)
{
if(!hash[flag[i]])
hash[flag[i]] = j++;
}
BuildTree(1, 1, maxm);
for(i = 1; i <= n; i++)
{
x = hash[a[i].l];
y = hash[a[i].r];
Update(1, i, x, y);
}
memset(hash, 0, sizeof(hash));
ans = 0;
Query(1);
printf("%d\n", ans);
}
}
void BuildTree(int i, int l, int r)
{
node[i].left = l;
node[i].right = r;
node[i].num = 0;
if(l == r) return;
int mid = (l + r) >> 1;
BuildTree(i << 1, l, mid);
BuildTree(i << 1 | 1, mid + 1, r);
}
void Update(int i, int num, int l, int r)
{
if(node[i].left == l && node[i].right == r)
{
node[i].num = num;
return;
}
if(node[i].num != -1)
{
PushDown(i);
node[i].num = -1;
}
int mid = (node[i].left + node[i].right) >> 1;
if(r <= mid) Update(i << 1, num, l, r);
else if(l > mid) Update(i << 1 | 1, num, l, r);
else
{
Update(i << 1, num, l, mid);
Update(i << 1 | 1, num, mid + 1, r);
}
}
void PushDown(int i)
{
node[i << 1].num = node[i << 1 | 1].num = node[i].num;
}
void Query(int i)
{
if(node[i].num != -1)
{
if(node[i].num > 0 && hash[node[i].num] == 0)
{
hash[node[i].num] = 1;
ans++;
}
return;
}
else
{
Query(i << 1);
Query(i << 1 | 1);
}
}
