有序离散化

我们这里讨论的是保序的离散化，小的在前面，大的在后面

我们有一个集合a[]，这个集合的值域是0 ~ $10^9$，但是这个集合中元素的个数却只有$10^5$个。

当我们需要将这个集合中元素当作下标时，那么我们需要开一个$10^9$数组，这无疑是很浪费空间的。

此时就需要进行映射，将这$10^5$个数映射到从0开始的自然数0~$10^5$上。这个过程就叫离散化。

离散化中可能遇到的问题：

• 这$10^5$个元素中有重复元素，需要去重
• 如何算出离散化后的值，可以通过二分

例题

假定有一个无限长的数轴，数轴上每个坐标上的数都是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

输入样例

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

输出样例

8
0
5

代码

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

using namespace std;

typedef pair<int,int> PII;
// 插入操作总数100000，查询操作总数100000，但查询有2个坐标l，r
// 所以开了300000的数组
const int N = 300010;
int n,m;
int a[N]; // 原始数组
int s[N]; // 前缀和

vector<int> alls; // 离散化后结果
vector<PII> add,query;

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;
}
int main()
{
    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());
    // unique，删除重复元素，把不重复的放到前面去，返回新数组最后一个位置
    // 之后调用erase把新数组最后一个位置到原数组最后一个位置元素全部删掉
    alls.erase(unique(alls.begin(),alls.end()),alls.end());
    
    // 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]所有a中不重复的数

    //     return a.begin()+j;
    // }
    // alls.erase(unique(alls),alls.end());

    // 处理插入
    // C++11特性，遍历add
    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;
}