Mayor's posters POJ - 2528 线段树&&离散化

Mayor's posters POJ - 2528

题意 ： 在墙上贴海报， n（n<=10000)个人依次贴海报,给出每张海报所贴的范围li，ri（1<=li<=ri<=10000000)。求出最后还能看见多少张海报。

分析 ： 很容易想到利用线段树来成段置换，最后统计总区间不同数的个数。但是这里有一个问题，就是区间可以很大，线段树开不了那么大的空间，遂想能不能离散化。实际上只记录坐标的相对大小进行离散化最后是不影响我们计算的，但是光是普通的离散化是不行的，就是我们贴海报的实际意义是对(l, r)段进行添加，而不是对于这个区间的点进行添加，是段树不是点树，如果这样普通离散化的话就会出现一个问题，比如数据1-10、1-4、6-10 行的，我们离散化后是1-4、1-2、3-4 ，不离散的结果是 3 但是离散化后再计算就是 2 了！原因就是我们是成段更新而不是点更新，进行添加海报的(l, r)的意义是对这一段进行添加，而离散化之后将原本不相邻的点变成了相邻的点，就导致了上面例子 4 - 6被覆盖了！解决这个问题的方法就是，在离散化的时候，将原本不相邻的两个点中间添加一个数，来表示中间是有“缝隙”的。

以1-10、1-4、6-10  为例

排序去重后的pre数组          1    4    6    10

离散化后排序的pre数组       pre[0]=1 ,pre[1]= 3 ,pre[2]=4 ,pre[3]=5,pre[4]=6, pre[5]=9, pre[6]=10

可以发现1到4中间增加了一个数，4到6中间增加了一个数，6到10中间增加了一个数。（有些增加的数并没有用，但他不会影响最后的统计结果）

先是 1~10染色，然后是1~4染上另一种颜色，最后是 6~10染上其它的颜色

#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
const int maxn=262144;
int pre[maxn];
int col[maxn];
bool vis[maxn];
int cnt;
struct node
{
    int ls,rs;
};
node s[maxn];
void pushup(int rt)
{
    if(col[rt])
    {
        col[rt<<1]=col[rt<<1|1]=col[rt];    //这里是把父节点的信息传递给子节点  所以update()中不能递归更新
        col[rt]=0;
    }
}
void update(int L,int R,int c,int l,int r,int rt)  
{
    if(L<=l && R>=r)
    {
        col[rt]=c;
        return ;
    }
    pushup(rt);   
    int m=(l+r)>>1;
    if(L<=m)
        update(L,R,c,l,m,rt<<1);
    if(m<R)
        update(L,R,c,m+1,r,rt<<1|1);
}
void query(int l,int r,int rt)
{
    if(col[rt])  //下面的这一段都是 col[rt] 了， 所以不必再往下更新
    {
        if(!vis[col[rt]])
        {
            cnt++;
            vis[col[rt]]=1;
        }
        return ;
    }
    if(l==r) return ;
    int m=(l+r)>>1;
    query(l,m,rt<<1);
    query(m+1,r,rt<<1|1);
}
int main()
{
    int t,n;
    scanf("%d",&t);
    while(t--)
    {
        memset(vis,0,sizeof(vis));
        memset(col,0,sizeof(col));
        int top=0;
        scanf("%d",&n);
        for(int i=0;i<n;i++)
        {
            scanf("%d%d",&s[i].ls,&s[i].rs);
            pre[top++]=s[i].ls;
            pre[top++]=s[i].rs;
        }
        //离散化处理
        sort(pre,pre+top);
        top=unique(pre,pre+top)-pre;  //将点去重
        for(int i=top-1;i>0;i--)
        {
            if(pre[i]!=pre[i-1]+1)   //在原本不相邻的点中间添加一个数，因为后面是要sort的，所以添加在数组末尾即可
                pre[top++]=pre[i]-1;   //要做到这个操作只要从后往前判断就可以了，或者一开始把top的值记下来也行
        }
        sort(pre,pre+top);
        for(int i=0;i<n;i++)
        {
            int l=lower_bound(pre,pre+top,s[i].ls)-pre;//在离散化之后的坐标系arr中寻找左端点
            int r=lower_bound(pre,pre+top,s[i].rs)-pre;//寻找右端点
            update(l+1,r+1,i+1,1,top,1);//更新，注意离散化之后的坐标是从0开始的，这里我们把坐标人为+1进行计算
        }
        cnt=0;
        query(1,top,1);
        printf("%d\n",cnt);//查询整个区间统计不同数的个数
    }
    return 0;
}

参考博客：http://www.cnblogs.com/Rubbishes/p/7382858.html