离散化区间和

离散化区间和

​ 当我们遇到存储下标特别大，并且需要存储的数量却比较稀疏，根本不需要开那么大的数组用来保存数据，此时我们可以使用离散化来解决。

​ 离散化的本质是映射，将间隔很大的点，映射到相邻的数组元素中，减少对空间的需求，也减少计算量。

先举个使用离散化的例子

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

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

输入格式

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

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

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

输出格式

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

输入样例：

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

输出样例：

8
0
5

思路：将需要的坐标包含区间端点进行离散化，保存到一个列表中，比如这个离散化的列表为alls,因为要将3个位置的整数加上c,alls列表中当前的列表的值为{1，3，7，1，3，4，6，7，8}，注意我这列表中保存了将要改变值的下标index和区间端点。因为要询问区间，所以需要排序，里面有重复的元素（重复的没啥用），所以也需要去重，排序去重后alls的值为{1，3，4，6，7，8}，还是用图舒服些

了解原理了，代码也就好写了,咱就不输入了，直接把案例的数据拿来就行

    static int N = 3000010;
    static int[] a = new int[N];  //这是映射后的数组
    static int[] s = new int[N];    //a数组的前缀和数组

    static List<Integer> alls = new ArrayList<>();//用来保存真实的下标和想象的下标的映射关系(所有要离散化的值)
    static Map<Integer,Integer> add = new HashMap<>();//原来保存操作输入的值
    static Map<Integer,Integer> query = new HashMap<>();//原来保存操作输入的值

	
    public static void main(String[] args) {
        //不写输入输出了，直接创造数据
        //add存储坐标与增加的值
        add.put(1,2);
        add.put(3,6);
        add.put(7,5);

        //alls存储使用过的坐标
        alls.add(1);
        alls.add(3);
        alls.add(7);

        //query保存要查询的区间范围
        query.put(1,3);
        query.put(4,6);
        query.put(7,8);

        //将其左右端点也映射进来，目的是可以让我们在虚拟的映射表里找到，
        //这对于我们后面的前缀和操作时是十分的方便的。如果当我们在虚拟的
        //映射表里找的时候，如果没有找到左右端点，那么前缀和无法求
        alls.add(1);
        alls.add(3);
        alls.add(4);
        alls.add(6);
        alls.add(7);
        alls.add(8);

        //alls排序并去重
        unique(alls);

        //a数组是散列后的数组
        for (Map.Entry<Integer, Integer> entry : add.entrySet()) {//先对添加里的元素映射 赋值
            int x = find(entry.getKey());//找到x的映射值
            a[x] += entry.getValue();// 处理插入
        }

        //a数组的前缀和
        for (int i = 1; i <= alls.size(); i++) {
            s[i] = s[i - 1] + a[i];//前缀和
        }
        for (Map.Entry<Integer, Integer> entry : query.entrySet()) {
            int l = find(entry.getKey());       //离散化后的左区间
            int r = find(entry.getValue());     //离散化后的右区间

            System.out.println(s[r] - s[l - 1]);
        }
    }

	//二分查找
    static int find(int x){
        int l = 0, r = alls.size() - 1;
        while(l < r){
            int mid = l + r >> 1;
            if(alls.get(mid) >= x){
                r = mid;
            }else{
                l = mid + 1;
            }
        }
        return r + 1;//  因为要求前缀和，故下标从1开始方便，不用额外的再处理边界。
    }
    //alls排序去重
    //排序后，重复的元素都挨在一起，只需要重复元素的第一个即可
    static void unique(List<Integer> list){
        //对alls进行排序
        list.sort(new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return o1 - o2;
            }
        });

        //这是排序后去重
        /*
        双指针:i正常遍历，0-j保存不重复元素
         */
        int j = 0;
        for (int i = 1; i < list.size(); i++) {
            if(list.get(j) != list.get(i)){
                list.set(++j,list.get(i));
            }
        }
        //将重复元素删除
        //从后往前遍历
        for (int i = list.size() - 1; i >= j + 1; i--) {
            list.remove(i);
        }
    }