2022/11/09 算法练习 力扣 2080. 区间内查询数字的频率

1、题目描述

请你设计一个数据结构，它能求出给定子数组内一个给定值的 频率 。

子数组中一个值的 频率 指的是这个子数组中这个值的出现次数。

请你实现 RangeFreqQuery 类：

• RangeFreqQuery(int[] arr) 用下标从 0 开始的整数数组 arr 构造一个类的实例。
• int query(int left, int right, int value) 返回子数组 arr[left...right] 中 value 的 频率 。

一个 子数组 指的是数组中一段连续的元素。arr[left...right] 指的是 nums 中包含下标 left 和 right 在内 的中间一段连续元素。

提示：

• 1 <= arr.length <= 105
• 1 <= arr[i], value <= 104
• 0 <= left <= right < arr.length
• 调用 query 不超过 105 次。

示例 1：

输入： ["RangeFreqQuery", "query", "query"] [[[12, 33, 4, 56, 22, 2, 34, 33, 22, 12, 34, 56]], [1, 2, 4], [0, 11, 33]]

输出： [null, 1, 2]

解释： RangeFreqQuery rangeFreqQuery = new RangeFreqQuery([12, 33, 4, 56, 22, 2, 34, 33, 22, 12, 34, 56]); rangeFreqQuery.query(1, 2, 4); // 返回 1 。4 在子数组 [33, 4] 中出现 1 次。 rangeFreqQuery.query(0, 11, 33); // 返回 2 。33 在整个子数组中出现 2 次。

2、完整代码

class RangeFreqQuery {
    Map<Integer,List<Integer>> map;
    public RangeFreqQuery(int[] arr) {
        map = new HashMap<>();
        for(int i=0;i<arr.length;i++){
            List<Integer> list = map.getOrDefault(arr[i],new ArrayList<>());
            list.add(i);
            map.put(arr[i],list);
        }
    }
    public int query(int left, int right, int value) {
       List<Integer> list = map.get(value);
       if(list == null){
           return 0;
       }else{
           int l =LeftBinarySearch(left,list);
           int r =RightBinarySearch(right,list);
           return r-l;
        }   
    }
    public int LeftBinarySearch(int left,List<Integer> list){
        int l = 0;
        int r = list.size();
        while(l < r){
            int mid = (r+l)/2;
            if(left <= list.get(mid))   r = mid;
            else   l = mid + 1;
        }
        return l;
    }
     public int RightBinarySearch(int right,List<Integer> list){
        int l = 0;
        int r = list.size();
        while(l < r){
            int mid = (r+l)/2;
            if(right >= list.get(mid))   l = mid+1;
            else   r = mid;
        }
        return l;
    }
}

3、分析

 

class RangeFreqQuery{
    private int[] a;
    public RangeFreqQuery(int[] arr) {
        a = arr;
    }
    public int query(int left, int right, int value) {
        int sum=0;
        for(int i=left;i<=right;i++){
            if(value == a[i])  sum++;
        }
        return sum;
    }
}

• 一开始看到题目我还说怎么这个题目会是中等难度，然后就直接拿到数组开始循环累计出现次数，失败之后发现这道题目的难度在于他对时间复杂度有一定的要求。怪不得要让我们实现类。

• 那么就要给定的类中将给定的数组安排好，转换成另一种形式，方便query计算，以达到降低时间复杂度的需求。
  • 首先想到哈希表，用Map直接记录每一个元素的对应出现的位置
  • 然后在Map中的List集合中拿到在left和right之间的下标，计算下标数量
• 本来想把二分查找合并，结果发现合并之后因为要判断是找左边还是右边，所以时间复杂度变高，所以就放弃了

public int BinarySearch(int aim,List<Integer> list,int flag){
        int l = 0;
        int r = list.size();
        if(flag==0){   //找小的，向右边靠
            while(l < r){
            int mid = (r+l)/2;
            if(aim <= list.get(mid))   r = mid;
            else   l = mid + 1;
            }
        }   
        if(flag==1){     //找大的，向左边靠
             while(l < r){
            int mid = (r+l)/2;
            if(aim >= list.get(mid))   l = mid+1;
            else   r = mid;
             }
        }
        return l;
    }

• 去看了时间复杂度最少的代码，心情稍稍有点复杂...

class RangeFreqQuery {

    private int[] arr;
    private int[] freq;

    public RangeFreqQuery(int[] arr) {
        int n = arr.length;
        this.arr = arr;
        this.freq = new int[n];
        int[] cnt = new int[10001];
        for (int i = 0; i < n; i++) {
            freq[i] = cnt[arr[i]]++;
        }
    }
    public int query(int left, int right, int value) {
        int l = right, r = left;
        for (int i = left; i <= right; i++) {
            if (arr[i] == value) {
                l = i;
                break;
            }
        }
        for (int i = right; i >= l; i--) {
            if (arr[i] == value) {
                r = i;
                break;
            }
        }
        return arr[l] != value ? 0 : freq[r] - freq[l] + 1;
    }