AcWing--802.区间和（离散化）

离散化（百度百科）：

离散化，就是把无限空间中有限的个体映射到有限的空间中去，以此提高算法的时空效率。

通俗的说，离散化是在不改变数据相对大小的条件下，对数据进行相应的缩小（这带来的是存储空间得缩小，访问效率的提高，即提高时空效率）。例如：

原数据：1,999,100000,15；处理后：1,3,4,2；（1映射到1，999映射到3......）

原数据：{100,200}，{20,50000}，{1,400}；处理后：{3,4}，{2,6}，{1,5}；

原题：

假定有一个无限长的数轴，数轴上每个坐标上的数都是 0。

现在，我们首先进行 n 次操作，每次操作将某一位置 x 上的数加 c。

接下来，进行 m 次询问，每个询问包含两个整数 l 和 r，你需要求出在区间 [l,r] 之间的所有数的和。

输入格式

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

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

再接下来 m 行，每行包含两个整数 l 和 r。

输出格式

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

数据范围

−109≤x≤109,
1≤n,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

用到的算法：离散化、前缀和、二分

用到的STL：vector

思路：

 主要是解决两个问题：

Q1: alls[ ]中可能有重复元素，怎么去重？

A1: 用 sort() + unique() + erase() 组合来去重。

Q2: 怎么快速求到离散化后的结果？

A2: 用二分法快速求到离散化后的结果。

详解见代码注释（真的写的很详细了/下次不这么啰嗦了/撇嘴）。

代码：

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

using namespace std;

typedef pair<int, int> PII;

const int N = 300010;// 开30万是因为离散化后插入操作最多10万个下标，查询操作最多有20万个下标（一次查询有两个下标：l,r）所以加起来最对会用到30万个下标

int n, m;
int a[N], s[N];// a数组是离散化后的数组，s数组是a数组的前缀和数组

vector<int> alls;// alls存的是所有要离散化的位置：x,l,r（实际上就是将下标离散化）
vector<PII> add, query;// add用于存要加的数的位置x和值c，query用于存需要访问的区间左右端点下标：l,r 

// find函数用于求x离散化后的结果（用二分快速找到x对应的离散化的值，解决第二个问题：怎么快速求到离散化后的结果）
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;
    }
    // l,r是下标，如alls[]={100,10,2,99999,10} 先在去重那一步进行了排序+去重变成：alls[]={2,10,100,99999},返回的对应离散化的值={1,2,3,4}，就是一一对应关系。 
    return r + 1;// “+1”是为了映射到1,2,...n（下标从1开始，因为本题要用到前缀和，而前缀和下标从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);
    }

    // 去重(附赠一个排序)
    // 解决第一个问题：alls[]中可能有重复的元素，要去重
    // 因为unique()函数是：“删除”相邻的重复元素，实际上是将重复的元素全部放到alls数组的末尾。返回去重后的尾元素的指针，alls的大小并没有改变。
    // 所以要先对alls排序，再用erase()函数删除被移动到alls数组末尾的所有重复元素。
    // 小结：sort()+unique()+erase()组合可以实现数组去重操作
    sort(alls.begin(), alls.end());// 对alls从小到大排序
    alls.erase(unique(alls.begin(), alls.end()), alls.end());// 把alls中重复的数删去，alls.size()会变（会影响find()函数）


    // 处理插入
    for(int i=0;i<add.size();i++)
	{
		int x=find(add[i].first);// add[i].first(即x）为要加数字的位置
		a[x]+=add[i].second;// add[i].second为要加的数字的值
	} 

    // 预处理前缀和
    for (int i = 1; i <= alls.size(); i ++ ) s[i] = s[i - 1] + a[i];

    // 处理询问
    for(int i=0;i<query.size();i++)
	{
		int l=find(query[i].first),r=find(query[i].second);// l是离散化后左端点的值，r是离散化后右端点的值。
		cout<<s[r]-s[l-1]<<endl;	
	} 

    return 0;
}

 代码流程：

①第一个for循环：先把要加的数的位置 x 及值 c 存入add，再把要加的数的位置 x 存入alls.

②第二个for循环：先把要访问的区间的做优端点 l，r 存入query，再分别把他们存入alls.

③去重：先对alls从小到大排序，再对alls去重。

④处理插入：调用find()函数将要加的值的小标离散化，再将值加到对应位置上。

⑤预处理前缀和：用s[N]数组存a[N]数组的前缀和。

⑥处理询问：调用find()函数将要询问的左右区间端点下标离散化，再用前缀和s[N]数组求区间和。