离散化

离散化是一个很有用的东西，有时候有的数据很大，或者数据量很多，就可以通过离散化来处理数据。可以通过改变他们的大小，但不改变他们的大小关系，可以节省空间，减低时空复杂度。

https://blog.csdn.net/xiangaccepted/article/details/73276826

大佬的博客的解释：

离散化是什么：一些数字，他们的范围很大（0-1e9），但是个数不算多（1-1e5），并且这些数本身的数字大小不重要，重要的是这些数字之间的相对大小（比如说某个数字是这些数字中的第几小，而与这个数字本身大小没有关系，要的是相对大小）（6 8 9 4 离散化后即为 2 3 4 1）（要理解相对大小的意思）（6在这4个数字中排第二小，那么就把6离散化成2，与数字6本身没有关系， 8,9,4亦是如此）。

离散化思想：因为数字太大，导致没有办法开那么大的数组，又因为数字个数并不多，这时候就可以对它们进行离散化，离散化是改变了数字的相对大小，例如，有500000个数字，他们的范围是0-1e9的，这样就满足离散化的条件。

就比如说，你可以开一个5e5的数组，但是你不能开一个1e9的数组。只改变这些数字的相对大小。

离散化，首先要知道一些STL中的函数：unique和lower_bound和upper_bound。

然后就是离散化的方式了：

一般离散化分为两种：1.一种是对付有重复元素的离散化。2.另一种是对付无重复元素的离散化（复杂度低于第一种）。

一 . 有重复元素的离散化

#include<iostream>
#include<algorithm>
using namespace std;
const int N=1e5+7;
int t[N],a[N],b[N];
int main(){
    int n;
    cin>>n;
    for(int i=1;i<=n;i++){
        cin>>a[i];
        t[i]=a[i];
    }
    sort(t+1,t+n+1);
    int m=unique(t+1,t+n+1)-t-1; //求出的m为不重复的元素的个数
    for(int i=1;i<=n;i++)
    b[i]=lower_bound(t+1,t+m+1,a[i])-t; 
    //lower_bound寻找第一个大于等于这个数的下标 
    //a[i]为原来的数组,b[i]为离散化后的数组
    for(int i=1;i<=n;i++)
    cout<<b[i]<<endl;
    return 0;
} 

二 . 无重复的元素的离散化 

const int N=1e5+7;
struct node{
    int v,id;
    bool operator<(const node a)const{
    return v<a.v;  //排序用 
    }
}a[N];
int n,rank[N];
int main(){
    cin>>n;
    for(int i=1;i<=n;i++){
        cin>>a[i].v;
        a[i].id=i;
    }
    sort(a+1,a+n+1);
    for(int i=1;i<=n;i++)
    rank[a[i].id]=i;
} 

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

举个例子：

a: 3 6 5 10 8

id:1 2 3  4  5

排序以后：

a: 3 5 6 8 10

id:1 3 2 5  4

所以离散化以后：

a:     3 5 6 8 10

id:    1 3 2 5  4

rank:1 2 3 4  5

在按原来的顺序排列：

a:     3 6 5 10 8

rank:1 3 2  5  4