POJ2528 Mayor's posters 线段树区间更新+离散化

题目链接：http://poj.org/problem?id=2528

题目大意：一个长度为10^7的墙上有n张海报，可能相互重叠，告诉你每张海报的宽度（高度都一样）和先后的叠放次序，问没有被完全盖住的海报有多少张（海报端点不会落在瓷砖中间）。

分析：如果每个叶子节点都代表一块瓷砖，那么线段树会导致MLE，即单位区间的数目太多。实际上，由于最多有1W张海报，共计2W个端点，这些端点最多把墙分成2W-1个单位区间，我们只要对这2W-1个区间编号，然后建树即可，这就是离散化。对于这些单位区间：

（1）每个单位区间在线段树上都是叶子节点；

（2）每个单位区间要么被全部覆盖，要么全部露出；

（3）没有海报的端点会落在一个单位区间内部；

（4）每张海报一定完整覆盖若干个连续的单位区间。

我们要算出一共有多少个单位区间，并且算出每张海报覆盖的单位区间需要nlong(n)的时间，实现上也不易实现。

更好的离散化方法，是将多有海报的端点瓷砖排序，把每张海报的端点瓷砖都看做一个单位区间，两个相邻的瓷砖之间的部分也是一个单位区间，这样最多会有2W+(2W-1)个单位区间。

关键：插入数据的顺序--从上往下一次插入每张海报，这样能保证后插入的海报不会覆盖到先前插入的海报，同时标记插入海报的区间。我们依次对每一张新插入的海报判断，如果当前海报所在的区间没有被完全覆盖，计数器加一即可。

实现代码如下（C++交的WA，换G++交AC，不知道怎么回事）：

#include <cstdio>
#include <algorithm>
using namespace std;
const int maxn=10000010;
const int M=10010;
struct segment
{
    int l,r;
    int mid()
    {
        return (l+r)>>1;
    }
    bool cover;
}tree[M*16];
struct POST
{
    int l,r;
}post[M]; //表示每一张海报所占的原始区间
int pos[M*2]; //纪录海报所占的原始区间的瓷砖编号
int hax[maxn]; //hax[i]表示瓷砖i离散化区间后的编号
void build(int root,int l,int r)
{
    tree[root].l=l;
    tree[root].r=r;
    tree[root].cover=false;
    if(l==r) return ;
    int mid=tree[root].mid();
    build(root<<1,l,mid);
    build(root<<1|1,mid+1,r);
}
bool judge(int root,int l,int r)
{//插入一张正好覆盖区间[l,r]的海报，若返回true则说明此区间是可见的
    if(tree[root].cover) return false;
    if(tree[root].l==l&&tree[root].r==r)
    {
        tree[root].cover=true;
        return true;
    }
    bool flag;
    int mid=tree[root].mid();
    if(r<=mid) flag=judge(root<<1,l,r);
    else if(l>mid) flag=judge(root<<1|1,l,r);
    else
    {
        bool f1=judge(root<<1,l,mid);
        bool f2=judge(root<<1|1,mid+1,r);
        flag=f1||f2;
        //if(f1||f2) flag=true;
    }
    if(tree[root<<1].cover&&tree[root<<1|1].cover)
      tree[root].cover=true;
    return flag;
}
int main()
{
    int t,n;
    scanf("%d",&t);
    while(t--)
    {
        scanf("%d",&n);
        int cnt=0;
        for(int i=0;i<n;i++)
        {
            scanf("%d%d",&post[i].l,&post[i].r);
            pos[cnt++]=post[i].l;
            pos[cnt++]=post[i].r;
        }
        sort(pos,pos+cnt);
        cnt=unique(pos,pos+cnt)-pos; //去掉重复元素
        //离散化:
        int num=1;
        for(int i=0;i<cnt;i++)
        {
            hax[ pos[i] ]=num;
            if(i<cnt-1)
            {
                if(pos[i+1]-pos[i]==1) num++;
                else num+=2;
            }
        }
        build(1,1,num);
        //for(int i=0;i<n;i++)
          //printf("%d %d     %d %d\n",post[i].l,hax[ post[i].l ],post[i].r,hax[ post[i].r ]);
        int ans=0;
        for(int i=n-1;i>=0;i--)
          if(judge(1,hax[ post[i].l ],hax[ post[i].r ]))
            ans++;
        printf("%d\n",ans);
    }
    return 0;
}