1157. 子数组中占绝大多数的元素(leetcode周赛题目)

实现一个 MajorityChecker 的类，它应该具有下述几个 API：

MajorityChecker(int[] arr) 会用给定的数组 arr 来构造一个 MajorityChecker 的实例。
int query(int left, int right, int threshold) 有这么几个参数：
0 <= left <= right < arr.length 表示数组 arr 的子数组的长度。
2 * threshold > right - left + 1，也就是说阀值 threshold 始终比子序列长度的一半还要大。
每次查询 query(…) 会返回在 arr[left], arr[left+1], …, arr[right] 中至少出现阀值次数 threshold 的元素，如果不存在这样的元素，就返回 -1。

示例：

MajorityChecker majorityChecker = new MajorityChecker([1,1,2,2,1,1]);
majorityChecker.query(0,5,4); // 返回 1
majorityChecker.query(0,3,3); // 返回 -1
majorityChecker.query(2,3,2); // 返回 2

提示：

1 <= arr.length <= 20000
1 <= arr[i] <= 20000
对于每次查询，0 <= left <= right < len(arr)
对于每次查询，2 * threshold > right - left + 1
查询次数最多为500

这道题目我开始的想法是用map去储存每个元素的个数，但是map的读取存储会导致时间超限，后来想到可以用数组来存储，用一个数组的第x个值表示x这个元素的个数，这样速度会快很多。

用map去存储时，因为时间超限，想了一些优化的办法，但是最后反而结果出问题了，翻来覆去也没看出来问题，先记录下来，以后有空再回来看看是哪里出问题了：

class MajorityChecker {

    public int[] arr;
    public int max;
    public Map<Integer,Integer> map;
    public MajorityChecker(int[] arr) {
        max=0;
        this.arr=arr;
        map=new HashMap<Integer,Integer>();
        for(int i=0;i<arr.length;i++){
            if(map.containsKey(arr[i])){
                int t=map.get(arr[i])+1;
                max=t>max?t:max;
                map.put(arr[i],t);
            }else{
                map.put(arr[i],1);
            }
        }
    }
    
    public int query(int left, int right, int threshold) {
        Map<Integer,Integer> mapd=map;
        Map<Integer,Integer> mapa=new HashMap<Integer, Integer>();
        if(threshold>max){
            return -1;
        }else {
            if(right-left>=arr.length-right+left){

                for (int i = 0; i < left; i++) {
                    mapd.put(arr[i], mapd.get(arr[i]) - 1);
                }
                for (int i = right + 1; i < arr.length; i++) {
                    mapd.put(arr[i], mapd.get(arr[i]) - 1);
                }
                for (Integer i:mapd.keySet()) {
                    if(mapd.get(i)>=threshold){
                        return i;
                    }
                }
                return -1;
            }else{
                for (int i = left; i <=right; i++) {
                    if(mapa.containsKey(arr[i])){
                        int t=mapa.get(arr[i])+1;
                        mapa.put(arr[i],t);
                    }else{
                        mapa.put(arr[i],1);
                    }
                }
                for (Integer i:mapa.keySet()) {
                    if(mapa.get(i)>=threshold){
                        return i;
                    }
                }
                return -1;
            }
        }
    }
}

主要优化就是：

1. 在初始化实例时，就计算出最大的元素个数，如果threshold>max 那么就返回-1。
2. 判断right-left是否大于arr.length-right+left，这样可以保证循环的个数小于arr.length/2。

这种方法又长又容易出错…

后来用int数组去存储直接就通过了，完全不需要啥优化…

class MajorityChecker {

    public int[] arr;
    public MajorityChecker(int[] arr) {
        this.arr=arr;
    }
    
    public int query(int left, int right, int threshold) {
        int[] res = new int[20001];
        for (int i = left; i <= right; i++) {
            res[this.arr[i]]++;
            if (res[this.arr[i]] >= threshold) return this.arr[i];
        }
        return -1;
    }
}

针对这种题目引以为戒，以后如果需要储存有范围的int类型为key的map，可以替换为数组去直接存储。