概念
离散化是一种将连续数据映射到离散值的过程。它通常用于优化某些算法，尤其是与区间查询相关的问题。
在离散化过程中，我们将一组实数转换为一组整数，使得原始数据的顺序和区间关系得以保留。具体地说，我们将原始数据排序，然后为每个不同的值分配一个整数。这个整数是该值在排序后出现的位置，即离散化后的数值。
假设我们有以下一组实数：{3.5 , 2.1 , 5.6 , 1.2 ,3.5,3.5,2.1,5.6,1.2,3.53.5,2.1,5.6,1.2,3.5}。对它们进行排序后，得到 {1.2 , 2.1 , 3.5 , 3.5 , 5.6 1.2, 2.1, 3.5,3.5,5.61.2,2.1,3.5,3.5,5.6}。接着，我们可以为每个不同的值分配一个整数，例如：
1.2 → 1
2.1 → 2
3.5 → 3
5.6 → 4
最终，我们将原始数据替换为离散化后的整数，得到 {3 , 2 , 4 , 1 , 3} 。这些整数可以用于解决一些与区间查询相关的问题，例如线段树、树状数组等算法。
当整数范围很大，比如大到1e9，而数据范围很小，只有1e5甚至更小，我们若是想经常查询或者修改这些整数的位置，显而易见哈希就是很好的方法，但是由于整数太大，没有那么多数组将其存下，此时我们就可以用离散化的方法来解决
离散化：离散化的本质是建立了一段数列到自然数之间的映射关系（value -> index)，通过建立新索引，来缩小目标区间，使得可以进行一系列连续数组可以进行的操作比如二分，前缀和等…
简而言之就是使用一个新的数组，这个新数组的值是原序列的下标，利用这个关系，建立起新数组的下标与原序列的关系，桥梁就是 新数组的值 == 原序列的下标
注意，原序列的下标是离散的，不是相邻的
举个例子
原序列前5个数的下标和值是 arr[0] = 1 ,arr[10] = 20 arr[200] = 300 arr[3000] = 5000 arr[40000] = 10000
新数组alls [0] = 0,alls[1] = 10,alls[2] = 200,alls[3] = 3000,alls[4] = 40000
注意观察橙色的数字，我们会发现，arr的下标就是alls数组的
这样我们就可以得到一个关系，arr [ alls[0] ] = 1, arr[ alls[ 1] ] = 20,arr[ alls [ 2]] = 300 , arr[ alls [3]] = 5000,arr[ alls[ 4]] = 10000;
这样是不是就变得很简单， 很清晰了 离散化就是这样一种很简单的坐标映射
ps : 实际上我们在处理arr的数据时，是不开arr这个数组，而是直接把arr的下标存入alls中，毕竟arr也没法开那么大
模板
vector<int> alls; // 存储所有待离散化的值
sort(alls.begin(), alls.end()); // 将所有值排序
alls.erase(unique(alls.begin(), alls.end()), alls.end()); // 去掉重复元素
// 二分求出x对应的离散化的值
int find(int x) // 找到第一个大于等于x的位置
{
int l = 0, r = alls.size() - 1;
while (l < r)
{
int mid = l + r >> 1;
if (alls[mid] >= x) r = mid;
else l = mid + 1;
}
return r + 1; // 映射到1, 2, ...n
}
模板题
AcWing 802. 区间和
(本题综合了二分与前缀和，是个很好的模板题)
假定有一个无限长的数轴，数轴上每个坐标上的数都是0。
现在，我们首先进行 n 次操作，每次操作将某一位置x上的数加c。
接下来，进行 m 次询问，每个询问包含两个整数 l 和 r，你需要求出在区间 [ l , r ] 之间的所有数的和。
输入格式：
第一行包含两个整数 n 和 m 。
接下来 n 行，每行包含两个整数 x 和 c 。
再接下来 m 行，每行包含两个整数 l 和 r 。
输出格式：
共 m 行，每行输出一个询问中所求的区间内数字和。
数据范围：
−109 ≤ x ≤ 109
1 ≤ n ≤ 105
1 ≤ m ≤ 105
−109 ≤ l ≤ r ≤109
− 10000 ≤ c ≤ 10000
输入样例：
3 3
1 2
3 6
7 5
1 3
4 6
7 8
输出样例：
8
0
5
思路分析
由于1≤n≤105和1≤m≤105所掉用的数字范围较小，而数轴范围较大，故可以将通过离散化处理，将 -109~109范围缩为105左右，大大提高效率。
1 存入离散化下标
在这一步，我们将要把所有的用到的arr下标存入alls数组当中
或许有的人会问，为什么 l 和 r 也要存进去啊
因为l和r可能也是很大的那种数字，比如1e9，并且l和r对应的其实是原序列的下标，而我们访问的其实是alls的数组，所以要将其与alls映射所以我们也需要将其离散化
又有人也行会问了，那离散l和r后，怎么保证求前缀和操作时的正确性，不会出现区间乱了的问题吗。
这个就问的很好了，原序列 l 和 r 中间的下标 一定是l<i<r的，而alls数组接下来会排序并且去重，离散化后的数组，其对应的l和r的alls数组，它存的值也是有序的，这就保证了，离散后的l和r之间的下标一定都是大于l并且小于r的，那么我们就会发现，原l到r区间的数字一个都没有丢失，一个也没有额外增加，还是那些数字
这就很好的解决了疑问
for(int i=1;i<=n;i++){ //离散化增加值区间
std::cin>>x>>c;//将x位置处加上c
add.push_back({x,c});//保存一下下标和值
alls.push_back(x);//将下标读入离散数组，开始映射
}
for(int i=1;i<=m;i++){ //离散化查询区间
std::cin>>l>>r;//输出l到r区间的值
query.push_back({l,r});
alls.push_back(l);//将两个下标存入离散下标数组
alls.push_back(r);
}
2 排序去重
为什么一定要排序去重呢
排序是为了方便我们使用二分排序
去重是因为假设，我们 在修改时曾经用到过下标100，后来查询时又用到了下标 100，那么alls里面就会有两个100，那么alls会有两个下标映射这个值，也就是100这个值，这显然是不合理的，因为alls与原序列也是一一映射关系，只有确保唯一性，才能保证正确性
// 2 排序去重
sort(alls.begin(),alls.end());
alls.erase(unique(alls.begin(),alls.end()),alls.end());
在 C++ 中，unique 是一个算法，通常与 std::vector 或其他序列容器一起使用，以移除连续重复的元素。它的定义在
<algorithm>头文件中。unique 函数并不会真正修改容器的大小，而是将不重复的元素移动到前面，并返回一个指向新逻辑末尾的迭代器。随后可以使用 erase 方法来删除多余的元素。
3 插入操作
使用alls的下标映射新的数组，相信大家到这应该已经能理解了
for(auto item:add){
int x = find(item.first); //将这个下标在alls数组中找到，使用alls的下标作为下标
sum[x]+=item.second;
}
4 前缀和
for(int i=1;i<=alls.size();i++)sum[i] +=sum[i-1];
5 查询
for(auto item:query){
int l = find(item.first);
int r =find(item.second);
std::cout<<sum[r]-sum[l-1]<<std::endl;
}
6 完整代码
(注意范围问题，s是从1开始的数组，所以可以通过调整二分法，将返回下标都加上1。)
#include<iostream>
#include<vector>
#include<algorithm>
typedef std::pair<int,int>PLL;
int n,m;//n次询问，m次查询
int x,c;//在x加上 c
int l,r;//输出区间值
std::vector<int>alls;//所有的下标放的位置
std::vector<PLL>add;//插入修改值
std::vector<PLL>query;//查询操作 //或vector<PLL>add, query;
int sum[3000000];//离散化后的数组，变成前缀和数组
int find(int x){
int l = -1,r = alls.size();
int mid = l+r>>1;
while(l+1<r){
if(alls[mid]>=x)r=mid;
else l = mid;
mid = l+r>>1;
}
return l+1;// 由于S是从1开始的，所以对应映射位置都往前提一位
}
int main(){
std:: cin>>n>>m;
// 1 第一步 离散化下标
for(int i=1;i<=n;i++){ //离散化插入区间
std::cin>>x>>c;
add.push_back({x,c});
alls.push_back(x);
}
for(int i=1;i<=m;i++){ //离散化查询区间
std::cin>>l>>r;
query.push_back({l,r});
alls.push_back(l);
alls.push_back(r);
}
// 2 排序去重
sort(alls.begin(),alls.end());
alls.erase(unique(alls.begin(),alls.end()),alls.end());
// 3 插入操作
for(auto item:add){
int x = find(item.first); //将这个下标在alls数组中找到，使用alls的下标作为下标
sum[x]+=item.second;
}
// 4 前缀和
for(int i=1;i<=alls.size();i++)sum[i] +=sum[i-1];
// 5 查询
for(auto item:query){
int l = find(item.first);
int r =find(item.second);
std::cout<<sum[r]-sum[l-1]<<std::endl;
}
return 0;
}
代码
#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
#include<algorithm>
#include<vector>
using namespace std;
typedef pair<int, int> PII;
const int N = 3 * 1e5 + 10;
int a[N], s[N];
vector<int> alls;
vector<PII> add, query;
// 二分查找
int find(int x)
{
int l = 0, r = alls.size() - 1;
while (l < r)
{
int mid = l + ((r - l) >> 1);
if (alls[mid] >= x) r = mid;
else l = mid + 1;
}
return l + 1; // 由于S是从1开始的，所以对应映射位置都往前提一位
}
int main()
{
int n, m;
cin >> n >> m;
for (int i = 0; i < n; ++i)
{
int x, c;
cin >> x >> c;
add.push_back({x, c});
alls.push_back(x);
}
for (int i = 0; i < m; ++i)
{
int l, r;
cin >> l >> r;
query.push_back({l, r});
alls.push_back(l);
alls.push_back(r);
}
sort(alls.begin(), alls.end());
alls.erase(unique(alls.begin(), alls.end()), alls.end());
for (auto& item : add)
{
int x = find(item.first);
a[x] += item.second;
}
for (int i = 1; i <= alls.size(); ++i) s[i] = s[i - 1] + a[i];
for (auto& item : query)
{
int l = find(item.first), r = find(item.second);
cout << s[r] - s[l - 1] << endl;
}
return 0;
}
扫一扫
261
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
