【算法基础】(一)基础算法 --- 离散化

✨个人主页：bit me
✨当前专栏：算法基础
专栏简介：该专栏主要更新一些基础算法题，有参加蓝桥杯等算法题竞赛或者正在刷题的铁汁们可以关注一下，互相监督打卡学习

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

思路：

结合我们前缀和与二分的思想，对数据进行数组储存然后实现排序去重

1. 用数组来存储我们的值，前缀和以及下标。

Scanner scanner = new Scanner(System.in);
int n = scanner.nextInt();//n次操作
int m = scanner.nextInt();//m次询问
int N = 300010;//开辟最大数组
int[] a =  new int[N]; //存值
int[] s = new int[N];//存前缀和
List<Integer> alls = new ArrayList<>();//存储下标

2. 为了避免有重复乱序的，我们还需要去重然后排序

• 准备工作

List<Pair> add = new ArrayList<>();//用来存n次操作
List<Pair> query = new ArrayList<>();//用来存m次询问
//输入n次操作，每次操作存入add集合中，然后将下标x存入alls集合中
for(int i = 0 ; i < n ; i ++ ){
    int x = scanner.nextInt();
    int c = scanner.nextInt();
    add.add(new Pair(x,c));
    alls.add(x);
}
//输入m次询问，每次询问存入query集合中。l,r都存入alls集合中。
for(int i = 0 ; i < m ; i ++ ){
    int l = scanner.nextInt();
    int r = scanner.nextInt();
    query.add(new Pair(l,r));
    alls.add(l);
    alls.add(r);
}

• 排序

Collections.sort(alls);   //排序

• 去重

int unique = unique(alls);  //去重

public static int unique(List<Integer> list){
    int j = 0;
    for(int i = 0 ; i <= list.size() - 1; i ++ ){
        if(i == 0 || list.get(i) != list.get(i-1)){
            list.set(j,list.get(i)); //将不重复之后的数一个一个重新存入list中。
            j ++ ;
        }
    }
    return j;
}

3. 下标的查找，以及前缀和与二分查找的结合

• 前缀和

for(int i = 1 ; i <= alls.size() ; i ++ ) s[i] = s[i-1] + a[i]; 

• 二分

public static int find(int x ,List<Integer> list){
    int l  = 0;
    int r = list.size() - 1;
    while(l < r){
        int mid = ( l + r )/ 2;
        if(list.get(mid) >= x) r = mid;
        else l = mid + 1;
    }
    return l + 1;
}

• 下标的询问查找

for(Pair item : query){
    int l = find(item.first,alls); //
    int r = find(item.second,alls); //
    System.out.println(s[r] - s[l-1]); //
}

4. Pair类的实现

class Pair{
    int first;
    int second;
    public Pair(int x,int c){
        this.first = x;
        this.second = c;
    }
}

附上总的代码

public class Demo1 {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int n = scanner.nextInt();//n次操作
        int m = scanner.nextInt();//m次询问
        int N = 300010;//表示需要用到的下标数量，因为一开始可能重复，所以按照最大可能开最大的数组；
        int[] a =  new int[N]; //用来存值,从一开始的值，因为要用到前缀和，所以0不操作；
        int[] s = new int[N];//用来存前缀和，从一开始进行记录a数组；
        List<Integer> alls = new ArrayList<>();//用来存所有的下标，x,l,r;
        //因为可能会重复乱序，所以需要进行去重，排序；
        List<Pair> add = new ArrayList<>();//用来存n次操作
        List<Pair> query = new ArrayList<>();//用来存m次询问
        //输入n次操作，每次操作存入add集合中，然后将下标x存入alls集合中
        for(int i = 0 ; i < n ; i ++ ){
            int x = scanner.nextInt();
            int c = scanner.nextInt();
            add.add(new Pair(x,c));
            alls.add(x);
        }
        //输入m次询问，每次询问存入query集合中，因为l,r是求和的下标区间和，所以l,r都存入alls集合中。
        for(int i = 0 ; i < m ; i ++ ){
            int l = scanner.nextInt();
            int r = scanner.nextInt();
            query.add(new Pair(l,r));
            alls.add(l);
            alls.add(r);
        }

        Collections.sort(alls);   //排序，现在alls集合中存的是x，l，r所有值
        int unique = unique(alls);  //这一步是去重，因为l，x，r中可能有重复的数；
        alls = alls.subList(0,unique);  //将去重之后的alls的长度范围中的值重新赋值给alls集合中。

        //增强for循环 for(元素类型 变量名 ： 数组或者集合) 缺点：无下标，简单。
        for(Pair item : add){
            int index = find(item.first,alls);//
            a[index] += item.second;//
        }

        for(int i = 1 ; i <= alls.size() ; i ++ ) s[i] = s[i-1] + a[i]; //这是前缀和公式代码

        for(Pair item : query){
            int l = find(item.first,alls); //
            int r = find(item.second,alls); //
            System.out.println(s[r] - s[l-1]); //
        }

    }
    //去重（只要符合是第一个数或者后面一个数不等于前面一个数就是不重复的数）
    public static int unique(List<Integer> list){
        int j = 0;
        for(int i = 0 ; i <= list.size() - 1; i ++ ){
            if(i == 0 || list.get(i) != list.get(i-1)){
                list.set(j,list.get(i)); //将不重复之后的数一个一个重新存入list中。
                j ++ ;
            }
        }
        return j;
    }
    //二分查找（在集合中查找你现在的下标是在什么位置，因为需要符合我们要用的前缀和公式，要让下标不是从0输出，最低的下标是1，符合前缀和的从1开始，所以输出的值加1）
    public static int find(int x ,List<Integer> list){
        int l  = 0;
        int r = list.size() - 1;
        while(l < r){
            int mid = ( l + r )/ 2;
            if(list.get(mid) >= x) r = mid;
            else l = mid + 1;
        }
        return l + 1;
    }
}

//这是一个Pair类，用来存操作的类
class Pair{
    int first;
    int second;
    public Pair(int x,int c){
        this.first = x;
        this.second = c;
    }
}