Mayor's posters POJ - 2528 线段树 离散化 区间染色

 3天前AC的代码，今天看来问题颇多，有些地方并没有真正理解。

你对原力其实一无所知！（哭）

#include<iostream>
#include<algorithm>
#include<cstdio>
#include<cstring>
#define mem(a,b) memset(a,b,sizeof(a))

const int maxn=4e4+10;

using namespace std;

struct node{
    int l,r;
}e[maxn];

int ls(int p){return p<<1;}
int rs(int p){return p<<1|1;}

int nl,nr,ans;

int arr[maxn],col[maxn<<2],n;
bool vis[maxn];

void init(){
    mem(col,0);
    mem(vis,0);
    mem(arr,0);
    mem(e,0);
    ans=0;
}

void pushdown(int p){
    if(col[p]!=0){
        col[ls(p)]=col[p];
        col[rs(p)]=col[p];
        col[p]=0;
    }
}

void update(int l,int r,int c,int p){
    if(nl<=l&&r<=nr){
        col[p]=c;//改颜色
        return ;
    }
    /*if(l>nr) return ;
    if(r<nl) return ;
    if(l==r) return ;//不要让叶子节点向下传递*/
    //所以最后的效果就是 有相同颜色的段 有标记 多种颜色的段 col[p]=0
    pushdown(p);
    int mid=l+r>>1;
    if(nl<=mid)update(l,mid,c,ls(p));
    if(nr>mid)update(mid+1,r,c,rs(p));
}

void query(int l,int r,int p){
    if(col[p]!=0){
        if(!vis[col[p]]){//这个颜色没被统计过
            ans++;
            vis[col[p]]=1;
        }
        return ;
    }
    int mid=l+r>>1;
    if(l==r) return ;
    query(l,mid,ls(p));
    query(mid+1,r,rs(p));
}

int main(){
    int t;
    scanf("%d",&t);
    while(t--){
        int tot=0,m=0;
        init();
        scanf("%d",&n);
        for(int i=1;i<=n;i++){
            scanf("%d%d",&e[i].l,&e[i].r);
            arr[++tot]=e[i].l;
            arr[++tot]=e[i].r;
        }
        sort(arr+1,arr+1+tot);
        for(int i=1;i<=tot;i++){//去重
            if(arr[i]!=arr[i-1])
                arr[++m]=arr[i];
        }
        for(int i=m;i>1;i--){//加点
            if(arr[i]-arr[i-1]!=1) //中间间隔大于1的两点 因为相邻 离散化后会挨在一起 但其实中间是有间隔的
                arr[++m]=arr[i-1]+1;
        }
//        for(int i=1;i<=m;++i){
//        	cout<<arr[i]<<" ";
//		}
//		puts("");
        sort(arr+1,arr+1+m);
        for(int i=1;i<=n;i++){
            nl=lower_bound(arr+1,arr+1+m,e[i].l)-arr;
            nr=lower_bound(arr+1,arr+1+m,e[i].r)-arr;
//            cout<<"l "<<e[i].l<<" "<<nl<<"\n";
//            cout<<"r "<<e[i].r<<" "<<nr<<"\n";
            update(1,m+1,i,1);
        }
        query(1,m+1,1);
        printf("%d\n",ans);
    }
        return 0;
}

这个离散化非常清新脱俗：

arr还是很大的原坐标（添了一些点），全靠lower_bound离散化（不改变相对大小的情况下 把数变小了）。

为什么arr下标从1开始而不是0呢，因为lower_bound 时要减arr（而arr.begin=0）,这样离散化以后的小坐标才能是从1开始。

关于为什么要在原始相邻区间添一个节点，举个例子：

原本：[1,2]，[4,5]，[1,5] 四个区间，

（不加节点）离散化后的点：1->1，2->2，4->3，5->4

对应区间：[[1],[2]]，[[3],[4]]，[[1],[2],[3],[4]]

答案本该是3种颜色，现在是2种。

原因：

为什么普通的离散化会漏掉颜色呢？

可以看到2,3直接相邻，这让原本的不相邻的点2,4相邻了，自然也就覆盖掉了原本应该有的那个区段（理解原始的端点和线段树中表示区间的“节点”的不同）。

所以要在长度大于1的区间之间加一个虚节点，记录这个区间的颜色。

加的这个“节点”，其实是长度为1的一段单位区间。

（加节点）离散化后的点：1->1，2->2，3，4->4，5->5

对应区间：[[1],[2]]，[[4],[5]]，[[1],[2],[3],[4],[5]]

3种颜色 bingo

 

加了一个节点变成[1] [2] [3] [4] [5]，因为2和4之间间隔大于1，离散化之后（lower_bound后）会挨在一起（变成[2]和[3]），而添了一个节点后，

疑惑：端点和区间？