离散化是一种常用的技巧,有时数据范围太大,可以用来放缩到我们能处理的范围;
因为其中需排序的数的范围0---999 999 999;显然数组不肯能这么大;
struct Node
{
int val,pos;
其中val就是原输入的值,pos是下标;
然后对结构体按val从小到大排序(sort);
此时,val和结构体的下标就是一个一一对应关系,而且满足原来的大小关系;
for(i=1;i<=N;i++)
a[p[i].pos]=i;
因为其中需排序的数的范围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; ///离散化
}
}