离散化

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

通俗的说，离散化是在不改变数据相对大小的条件下，对数据进行相应的缩小。例如：

原数据：1,999,100000,15；处理后：1,3,4,2；

原数据：{100,200}，{20,50000}，{1,400}；

处理后：{3,4}，{2,6}，{1,5}；

---

有时候，我们要处理的数据范围非常大，但是数据量并不多，同时，我们需要知道的只是他们的相对大小关系，这时候，我们就可以对数据进行离散化处理。 比如现在在x轴上有n(n<100)个点，分别给出他们的坐标m(m<1e9)，询问你在坐标k左边的坐标数量有多少。

如果m小的话，我们完全可以使用桶排解决，但是m如果1e9的话，开数组肯定会炸（不要问为什么不用map，每一种算法肯定有他存在的意义），这时候我们就可以先对数据离散化。

---

现在有数据1 2 2 7 8 9 100 200 199999 1000000000

离散化有两种较常用的方法

• 第一种是将相等的数据离散化为相等的数据，上面的数据处理后的结果就是1 2 2 3 4 5 6 7 8 9

• 第二种是将相等的数据离散化为不相等的数据，上面的数据处理后的结果就是1 2 3 4 5 6 7 8 9 10

第一种，该方法用到unique()和lower_bound()，

因为不难理解，直接上代码

    int n = 10;
    int a[12], b[12]; //b数组用来存放去重后的数据
    for (int i = 1; i <= n; i++)
    {
        cin >> a[i];
        b[i] = a[i];
    }
    sort(b + 1, b + 1 + n);//unique 和 lower_bound都需要有序序列
    int len = unique(b + 1, b + 1 + n) - b; //记录b数组去重后的长度
    for (int i = 1; i <= n; i++)
        a[i] = lower_bound(b + 1, b + len, a[i]) - b; //离散化 利用二分查找 快速重新赋值

第二种，只需开个结构体即可，仔细看一遍就可理解，直接上代码

    struct node
    {
        int v, bh; //v表示离散化前的值
    } p[15];
    bool cmp(node a, node b)
    {
        return a.v < b.v;
    }
    int a[105]; //用来存放离散化后的数据
    
    int n = 10;
    for (int i = 1; i <= n; i++)
    {
        p[i].bh = i;
        cin >> p[i].v;
    }
    sort(p + 1, p + n + 1, cmp); //按值大小排序
    for (int i = 1; i <= n; i++)
        a[p[i].bh] = i;