离散化

离散化是一种常用的技巧，有时数据范围太大，可以用来放缩到我们能处理的范围；
因为其中需排序的数的范围0---999 999 999；显然数组不肯能这么大；

而N的最大范围是500 000；故给出的数一定可以与1.。。。N建立一个一一映射

这里用一个结构体
   struct Node
   {
      int val,pos;

   }p[510000];

和一个数组a[510000];

其中val就是原输入的值，pos是下标；
然后对结构体按val从小到大排序(sort)；
此时，val和结构体的下标就是一个一一对应关系，而且满足原来的大小关系；

   for(i=1;i<=N;i++)
   a[p[i].pos]=i;

然后a数组就存储了原来所有的大小信息；

比如 9 1 0 5 4 ------- 离散后的a数组

就是 5 2 1 4 3；

举例：

    数据：9 1 0 5 4  p[i].val
    编号：1 2 3 4 5  p[i].pos = i
    sort
    数据：0 1 4 5 9
    编号：3 2 5 4 1
    顺序：1 2 3 4 5

    a[p[i].编号] = 顺序号;
    
    a[3] = 1<--0;
    a[2] = 2<--1;
    a[5] = 3<--4;
    a[4] = 4<--5;
    a[1] = 5<--9;
      
    a[]={ 5 2 1 4 3 }
 编号：1  2 3 4 5

///具体代码

/************************************************
┆  ┏┓　　　┏┓ ┆
┆┏┛┻━━━┛┻┓ ┆
┆┃　　　　　　　┃ ┆
┆┃　　　━　　　┃ ┆
┆┃　┳┛　┗┳　┃ ┆
┆┃　　　　　　　┃ ┆
┆┃　　　┻　　　┃ ┆
┆┗━┓　  　┏━┛ ┆
┆　　┃　  　┃　　┆　　　　　　
┆　　┃　  　┗━━━┓ ┆
┆　　┃　 AC代马 　　┣┓┆
┆　　┃　        　　┏┛┆
┆　　┗┓┓┏━┳┓┏┛ ┆
┆　　　┃┫┫　┃┫┫ ┆
┆　　　┗┻┛　┗┻┛ ┆
************************************************ */
#include <iostream>
#include <cstdio>
#include <algorithm>
using  namespace std;
typedef  long  long  ll;
const int N = 5e5 + 10;

struct  node
{
    int val;
    int pos;
} p[N];

int n, a[N];

bool cmp(const node&a, const node& b)
{
    return a.val < b.val;
}
void solve()
{
    for (int i = 1; i <= n; i++)
    {
        scanf("%d", &p[i].val);
        p[i].pos = i;
    }
    sort(p + 1, p + n + 1, cmp); ///排序，最好用stable_sort !!!  此处高能掉坑预警
    for (int i = 1; i <= n; i++)
    {
        a[p[i].pos] = i;    ///离散化
    }
}