离散化

　　离散化，把无限空间中有限的个体映射到有限的空间中去，以此提高算法的时空效率 

那么举个栗子，某个题目告诉你有1e5个数，每个数大小不超过1e9，要你对这些数进行操作（比如并查集之类的）。那么肯定不能直接开1e9大小的数组，但是1e5的范围就完全没问题。在举个栗子，现在对{4,7,6,9}进行离散化，那么得到的结果是{1,3,2,4}，也就是说，当我们并不需要这些数据具体是多少时，就只需要知道他们的相对大小就行了。

离散化的方法有两种，一种是有重复元素的，一种是没有出现重复元素的。使用的时候务必要分清。

第一种：有重复元素的离散

const int maxn = 2e6+6;

int t[maxn],a[maxn];
int n;

int main(){
    scanf("%d",&n);
    for (int i=1;i<=n;i++){
        scanf("%d",&a[i]);
        t[i] = a[i];
    }
    sort(t+1,t+1+n);
    int size = unique(t+1,t+1+n)-t-1;
    for (int i=1;i<=n;i++){
        a[i] = lower_bound(t+1,t+1+size,a[i])-t;
    }
    for (int i=1;i<=n;i++){
        printf("%d ",a[i]);
    }
    return 0;
}

第二种：无重复元素的离散

这种方式的离散复杂度比第一种优秀，但是不可以处理重复的元素

const int maxn = 2e6+6;

struct Node{
    int v,id;
    bool operator < (const Node a)const{
        return v < a.v;
    }
}a[maxn];

int Rank[maxn],n;

int main(){
    scanf("%d",&n);
    for (int i=1;i<=n;i++){
        scanf("%d",&a[i].v);
        a[i].id = i;
    }
    sort(a+1,a+1+n);
    for (int i=1;i<=n;i++){
        Rank[a[i].id] = i;
    }
    for (int i=1;i<=n;i++){
        printf("%d ",Rank[i]);
    }
    return 0;
}

这种方法直接用结构体存储原本的数列的元素的位置，然后排序以后将他们再重新赋值。那么rank[]就是结构体a[]离散化后的结果。

　　举个栗子：

　　v: 3 6 5 10 8

　　id:1 2 3 4 5

　　排序以后：

　　v: 3 5 6 8 10

　　id:1 3 2 5 4

　　所以离散化以后：

　　v: 3 5 6 8 10

　　id:1 3 2 5 4

　　rk:1 2 3 4 5

　　在按原来的顺序排列：

　　v: 3 6 5 10 8

　　rk:1 3 2 5 4