算法离散化——区间和

最新推荐文章于 2024-06-15 23:36:03 发布

YoungPQAQ

最新推荐文章于 2024-06-15 23:36:03 发布

阅读量58

点赞数

文章标签：算法开发语言

本文链接：https://blog.csdn.net/KKforeverYoung/article/details/133847827

版权

如果值比较小（如-10 的 5 次方到 10 的 5 次方），直接用前缀和做。

如此一道题，如果在每个数组对应的下标填入对应的值，会造成一大堆数组位置用不到的情况

整个数值的跨度很大，但是很稀疏，这样的情况可以想到用离散化来做

所以可以把所有的数，映射到从 1 开始的自然数

import java.util.*;
public class Main{
    public static void main(String[] args){
        Scanner scan = new Scanner(System.in);
        int n = scan.nextInt();// 输入n次操作
        int m = scan.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 = scan.nextInt();
            int c = scan.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 = scan.nextInt();
            int r = scan.nextInt();
            query.add(new Pair(l,r));
            alls.add(l);
            alls.add(r);
        }

        Collections.sort(alls);   //排序，现在alls集合中存的是x，l，r所有值
        int unique = unique(alls);  // //注意事项②🌟
        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;
    }
}

注意事项

①：为什么要开辟 300000 个位置？答：首先 n，m 操作的次数范围为

按照最最最极端的情况下考虑，每次 n 、 m 操作（m 操作每次操作2 个数组的位置）。

所以假设为每次 n，m 都操作不同的下标。

②为什么要去重、排序？答：理解这个必须理解整道题的思路、核心点：离散化。该题的离散化，正是将要操作的数组下标进行离散化，如这道题的例子输入为示例，进行 add 操作时操作了 数组下标 1、3、7 ，进行 query 操作时操作了 数组下标1 3 4 6 7 8。alls 数组的作用就是将所有需要操作的下标集合起来到数组。

回到最初的问题，为什么要去重。正是因为离散化后的数组只需要知道 哪个数组下标需要操作

为什么要排序？离散化就是将被操作的数组下标，从小到大映射到 a 数组的序列中从 1 开始排序（因为需要进行前缀和操作，所以从 1 开始）