离散化模板总结

离散化的通俗解释

在学习之前，一直认为离散化和离散数学应该是相关的，但是两者没啥关系
离散化就是把大范围内稀疏的坐标映射到小范围内稠密的坐标

离散化的应用条件

不需要考虑数据的绝对大小，只需要看它们的相对大小
就是这个数到底是多少无所谓，只要知道相对次序就行，这种情况下就可以使用离散化

离散化实现思路

离线做法
首先将待离散化的数据进行存储，之后采用二分找到其在存储空间中的位置，从而实现将所有数值映射为其在序列中的位置
这样做的前提是待离散化的数据都已经进行了存储，即必须将数据全部进行读取后才可进行离散化

// 离散化的实现方式是将元素映射为它在序列中的位置(数组下标)
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
    // return r; // 映射到0，1，...n-1
    // 这里的n指的是总数据个数
}

在线做法
使用哈希，为每一个数值分配一个编号，从而实现从较大值映射为较小值
这样做并不需要保证数据全部读入，可以边读入边处理

// 将n映射为较小值
#include <unordered_map>

using namespace std;

int cnt;
unordered_map<int, int> id;

int main()
{
    int n;
    cin >> n;
    if (!id.count(n)) id[n] = ++ cnt; // if (id.find(n) == id.end()) id[n] = ++ cnt;
}

应用举例

问题

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

输入格式

第一行包含两个整数n和m。

接下来 n 行，每行包含两个整数x和c。

再接下里 m 行，每行包含两个整数l和r。输入格式：

输出格式

共m行，每行输出一个询问中所求的区间内数字和。

数据范围

(-10^9 <= x <= 10^9)

(1 <= n, m <= 10^5)

(-10^9 <= l <= r <= 10^9)

(-10000 <= c <= 10000)

如果不看数据范围，这道题明显用前缀和就能解决，但是前缀和需要使用数组下标进行坐标存储，x，l，r作为下标，题目所给的数据范围显然是不行的，但是这个下标到底是多少并不重要，重要的是知道它们之间的相对位置关系，比如说修改坐标改的是1和10000，询问的是500和600之间的和，也就是一共就1，500， 600， 10000这四个数，那这四个数如果变成0，1，2，3，对0和1进行修改，然后查询的是2和3和修改1和10000，查询500和600结果是一样的，500和600这个数据本身是多少并不重要，相对位置才重要，所以可以将坐标离散化到一个小区间中，此时的数组下标就可以承受得起了，就可以采用前缀和来做了

代码实现

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

using namespace std;

const int N = 3e5 + 10; // 因为修改会涉及到n个坐标，查询会涉及到2*m个坐标，最坏情况是这n+2*m个坐标全都不相等，那么映射后需要的空间最大也就3e5，+10减少边界问题

int n, m;
int a[N];
vector<pair<int, int>> adds, query;// 因为我们需要知道哪些坐标需要离散化，所以修改和查询操作需要先进行保存，不能直接处理了
vector<int> alls; // 保存需要进行离散化的坐标

// 通过二分巧妙实现将稀疏的数据映射到稠密的下标从而实现离散化
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; // 将坐标映射到[1, alls.size()]，而二分找到的结果是数组下标，应该是[0, alls.size() - 1]
}
int main()
{
    cin >> n >> m;
    
    // 读入修改操作
    for (int i = 0; i < n; ++ i)
    {
        int x, c;
        cin >> x >> c;
        adds.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 (int i = 0; i < n; ++ i)
    {
        int x = find(adds[i].first);
        a[x] += adds[i].second;
    }
    
    // 准备前缀和数组
    for (int i = 1; i <= alls.size(); ++ i) a[i] += a[i - 1];
    
    // 进行查询操作
    for (int i = 0; i < m; ++ i)
    {
        int l = find(query[i].first), r = find(query[i].second);
        cout << a[r] - a[l - 1] << endl;
    }
    return 0;
}