简单的离散化

适用环境：当所给数据之间的跨度特别大的时候且数据中有负数；
核心思想：映射 ，将所给数据重新映射到一个数组中如

在数轴位置为：12312，23，2，-123213124，3219上进行若干操作 然后再给出
L，R求[L,R]之间的和；

在这里只要将12312，23，2，-123213124，3219，L，R排序后 映射为1 2 3 4 5 6 7;即可

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

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

using namespace std;

const int N = 300010;

int n,m;

int a[N],s[N];//a[N]用来储存进行若干操作后所映射的坐标的值，s[N]用来求前缀和 
typedef pair<int,int> PII;
//pair 用来储存两个类型不一样的数值 
vector<PII> add,query; //add用来储存n次操作时的坐标和值，query用来储存m次询问的左右坐标 ;
vector<int> alls;//alls用来存储一共要用到那些坐标包含 需要操作的和需要询问的

int find(int x)//用来寻找离散化后的坐标 那二分查询能大大降低时间复杂度
{
    int l=0,r=alls.size()-1,mid;
    
    while(l<r)
    {
        int mid=(l+r)/2;
        if(alls[mid]>=x) r=mid;
        else
        l=mid+1;
    }
    
    return r+1;//返回r和r+1根据离散化后是0，1，2，3还是1，2，3，4；
}

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());//排序
    alls.erase(unique(alls.begin(),alls.end()), alls.end());//数组去重
    
    
    for(auto item : add)//item是将add开始遍历
    {
        int x=find(item.first);//first是来询问pair中的第一个值，find是来查找item.first离散化后应对应的值
        a[x]+=item.second;//second是用来询问pair的第二个值
    }
    
    for(int i=1;i<=alls.size();i++)//离散化后的坐标是从1开始的故要遍历到 alls.size（）处；
    {
        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;
}