POJ 2528 Mayor's posters

我所理解的离散化，感觉像是数组下标计数法和排序后再数的差别。

数组下标计数法，如果样例为1，1，10000000，那么需要至少a[10000001]的数组，其中a[1]=2,a[10000000]=1,其余都是零

如果数字范围很大，而输入又不是很多的时候，这种方法太浪费空间

常用方法是，先把输入序列排序，然后再找到相应数字计数 。那么上面的样例就变成了a[0]=1,a[1]=1,a[2]=10000000。

排序的过程，类似于这道题目中离散化的过程，即重新建立映射，把一些范围很广数量却不是很多的数字映射到紧密的数字排列中

#include <stdlib.h>
#include <cstdio>
#include <iostream>
#include <queue>
#include <stack>
#include <string.h>
#include <math.h>
#include <algorithm>

#define mem(t, v)   memset ((t) , v, sizeof(t))
#define INF 0x3f3f3f3f
#define eps 1e-8
typedef long long ll;

using namespace std;

const int MAX=200010;
int n,t,ans;
int st[MAX],ed[MAX],mark[MAX];
int hs[MAX];
struct node{
    int l,r,id;
}tree[MAX*4];
int lis[MAX];

void Build(int i,int l,int r){
    tree[i].r=r,tree[i].l=l,tree[i].id=0;
    if(l==r)return ;
    int mid=(l+r)>>1;
    Build(i<<1,l,mid);
    Build(i<<1|1,mid+1,r);
}

void Push_down(int i){
    int c=tree[i].id;
    if(c){
        tree[i<<1].id=tree[i<<1|1].id=c;
        tree[i].id=0;
    }
}

void Update(int i,int l,int r,int c){
    //printf("%d %d %d %d\n",i,l,r,c);
    if(tree[i].l>r||tree[i].r<l)return ;
    if(tree[i].l>=l&&tree[i].r<=r){
        //printf("%d %d--**\n",i,c);
        tree[i].id=c;
        return;
    }
    if(tree[i].r==tree[i].l)return;
    Push_down(i);
    if(tree[i<<1].r>=l)Update(i<<1,l,r,c);
    if(tree[i<<1|1].l<=r)Update(i<<1|1,l,r,c);
}

void Search(int i){
    if(tree[i].id){
        if(!mark[tree[i].id]){
            mark[tree[i].id]=1;
            ans++;
            return ;
        }
    }
    if(tree[i].l==tree[i].r)return ;
    Push_down(i);     //！！！
    Search(i<<1);
    Search(i<<1|1);
}

int main(){
    scanf("%d",&t);
    while(t--){
        int p=0;
        ans=0;
        scanf("%d",&n);
        for(int i=0;i<n;i++){
            int a,b;
            scanf("%d%d",&a,&b);
            lis[p++]=a,st[i]=a;
            lis[p++]=b,ed[i]=b;
        }
        sort(lis,lis+p);
        int cnt=0;
        //mem(hs,0);
        for(int i=0;i<p;i++){
            if(lis[i]!=lis[i-1])
                lis[cnt++]=lis[i];
        }
//        printf("%d+\n",cnt);
//        for(int i=0;i<cnt;i++){
//            printf("%d*++\n",lis[i]);
//        }
        for(int i=cnt-1;i>=1;i--){
            if(lis[i]-lis[i-1]>1)
                lis[cnt++]=lis[i-1]+1;
        }
        sort(lis,lis+cnt);
//        for(int i=0;i<cnt;i++){
//            printf("%d*\n",lis[i]);
//        }
//        printf("%d+\n",cnt);
        Build(1,1,cnt);
//        for(int i=1;i<=cnt;i++)
//            printf("%d %d %d\n",tree[i].l,tree[i].r,tree[i].id);
        for(int i=0;i<n;i++){
            //printf("%d %d--\n",hs[st[i]],hs[ed[i]]);
            int l=lower_bound(lis,lis+cnt,st[i])-lis+1;  //cnt从0开始所以此处+1，线段树的节点是从1开始算的
            int r=lower_bound(lis,lis+cnt,ed[i])-lis+1;
            Update(1,l,r,i+1);
        }
        mem(mark,0);
        Search(1);
        printf("%d\n",ans);
    }
}