1. 离散化的定义

离散化是一种在程序设计和算法优化中常用的技术，其核心思想是将无限空间中有限的个体映射到有限的空间中去，以此提高算法的时空效率。具体来说，离散化是在不改变数据相对大小的条件下，对数据进行相应的缩小或整合，使得原本稀疏的数据变得相对稠密（在相对位置或值域上）。这个过程可以看作是数据的一种规范化或标准化，但它保留了数据之间的相对关系。

简单来说，就是将极大空间中跨度很大的有限数据映射到有限且连续的空间中去，比如把题目中跨度极大的下标位置映射到1,2,3…n(大下标映射到小下标)，再创建一个数组(下标为小下标)来存储大下标对应的值。那么怎么找到大下标对应的小下标呢？可以通过创建find()函数来寻找，后面会详细介绍。使用离散化虽然增加了空间复杂度，但是大大优化了时间复杂度。

离散化的作用主要体现在以下几个方面：

1.提高算法效率：通过离散化，可以减少算法需要处理的数据量，从而降低时间复杂度和空间复杂度。这对于处理大规模数据或资源受限的环境尤为重要。
2.简化问题：在某些情况下，离散化可以将复杂的问题简化为更易于处理的形式。例如，在处理坐标或区间相关的问题时，通过离散化可以将坐标或区间映射到较小的整数范围内，从而简化问题的求解过程。
3.实现特殊算法：在某些算法中，由于数据范围过大或数据分布不均匀，直接处理可能会导致算法无法实现或效率极低。通过离散化，可以使得这些算法得以实现或提高效率。

离散化的具体实现方式通常包括以下几个步骤：

收集待离散化的数据——>排序——>映射——>替换

2. 离散化例题

原题链接：AcWing 802.区间和

题目描述：
假定有一个无限长的数轴，数轴上每个坐标上的数都是 0。现在，我们首先进行 n
次操作，每次操作将某一位置 x上的数加 c。接下来，进行 m次询问，每个询问包含两个整数 l和 r，你需要求出在区间 [l,r]之间的所有数的和。

输入格式：
第一行包含两个整数 n 和 m。
接下来 n 行，每行包含两个整数 x 和 c。
再接下来 m 行，每行包含两个整数 l 和 r。

数据范围：
−1e9≤x≤1e9,
1≤n,m≤1e5,
−1e9≤l≤r≤1e9,
−10000≤c≤10000

输入样例：

3 3
1 2
3 6
7 5
1 3
4 6
7 8

输出样例：

8
0
5

题目分析：首先，根据题意和数据范围可知数据跨度大，但是个数少，如果用普通的前缀和算法根本无法实现，因为x的范围是-1e9—1e9，下标位置存在负数，所以这道题使用离散化就非常符合条件

如何将不连续且跨度极大的数据下标映射到连续的数组下标呢？可以额外开辟一个vector容器alls来存储跨度极大的数据下标(被离散化的数据下标)，然后还得对alls进行排序(有序得离散化),去重(alls可能存在重复元素)，提供一个方法用来寻找数据映射后(离散化后)的下标，有两种方法：二分查找和哈希

vector<int> alls; //存储所以待离散化的下标
sort(alls.begin(),alls.end()); //排序
alls.erase(unique(alls.begin(),alls.end()),alls.end()); //去重

unique函数去重
返回去重（只去掉相邻的相同元素）之后的尾迭代器（或指针），仍然为前闭后开，即这个迭代器是去重之后末尾元素的下一个位置。该函数常用于离散化，利用迭代器（或指针）的减法，可计算出去重后的元素个数。

如何自己实现unique函数(使用双指针算法)

vector<int>::iterator unique(vector<int> &a)
{
    int j=0;
    for(int i=0;i<a.size();i++)
    {
        if(!i || a[i]!=a[i-1])
        {
            a[j++]=a[i];
        }
    }
    //a[0]~a[j-1]存储了所有不重复元素
    return a.begin() + j;
}

图解分析(来源大佬的题解分析)

2.1 离散化+二分

二分查找的时间复杂度为O(log n)

使用二分来实现查找映射后的下标，传入大下标的值，返回对应的小下标。最后返回的下标要加一，因为后面还要利用前缀和来求某个区间的和，而前缀和通常从下标为1开始 注意：alls的长度就是映射后的下标数，也是待询问区间的两端。

int find(int x)
{
    int l=0;
    int 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;
}

完整代码：

#include <iostream>
#include <vector>
#include <algorithm>

using namespace std;
const int N = 300010; //n次插入和m次查询相关数据量的上界
int n, m;
int a[N];//存储坐标插入的值
int s[N];//存储数组a的前缀和
vector<int> alls;  //存储（所有与插入和查询有关的）坐标
vector<pair<int, int>> add, query; //存储插入和询问操作的数据

int find(int 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; //返回的下标加一
}

int main() {
    //加速
    ios::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);
    cin >> n >> m;
    for (int i = 1; i <= n; i++) {
        int x, c;
        cin >> x >> c;
        add.push_back({x, c});
        alls.push_back(x);
    }
    for (int i = 1; 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());
    //执行前n次插入操作
    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];
    //处理后m次询问操作
    for (auto item : query) {
        int l = find(item.first);//找到区间的左端点
        int r = find(item.second);//找到区间的右端点
        cout << s[r]-s[l-1] << "\n";
    }

    return 0;
}

2.2 离散化+哈希表

用哈希表来查找映射后下标的值的时间复杂度通常为O(1)

AC代码

#include <iostream>
#include <vector>
#include <unordered_map>
#include <algorithm>

using namespace std;
const int N = 300010; //n次插入和m次查询相关数据量的上界
int n, m;
int a[N];//存储坐标插入的值
int s[N];//存储数组a的前缀和
vector<int> alls;  //存储（所有与插入和查询有关的）坐标
vector<pair<int, int>> add, query; //存储插入和询问操作的数据
unordered_map<int,int> mp; //哈希表

int main() {
    ios::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);
    cin >> n >> m;
    for (int i = 1; i <= n; i++) {
        int x, c;
        cin >> x >> c;
        add.push_back({x, c});
        alls.push_back(x);
    }
    for (int i = 1; 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());
    //将待离散化的值映射到下标
    int j=1;
    for(int i=0;i<alls.size();i++)
    {
        mp[alls[i]]=j++;//映射到下标从1开始
    }
    //执行前n次插入操作
    for (auto item : add) {
        int x = mp[item.first];//找到离散化后的小下标
        a[x] += item.second;//将数组中离散化后的小下标位置加上数据
    }
    //前缀和
    for (int i = 1; i <= alls.size(); i++) s[i] = s[i-1] + a[i];
    //处理后m次询问操作
    for (auto item : query) {
        int l = mp[item.first];//找到区间的左端点
        int r = mp[item.second];//找到区间的右端点
        cout << s[r]-s[l-1] << "\n";
    }

    return 0;
}

希望以上内容对大家有所帮助，对内容有异议的欢迎大家来讨论，多多支持哦！