[Leetcode][第632题][JAVA][最小区间][堆][滑动窗口]

【问题描述】[困难]

【解答思路】

1. 堆

复杂度

class Solution {
    public int[] smallestRange(List<List<Integer>> nums) {
    	//区间的左边和右边
        int rangeLeft = 0, rangeRight = Integer.MAX_VALUE;
        //最小范围
        int minRange = rangeRight - rangeLeft;
        //区间的左边最大值
        int max = Integer.MIN_VALUE;
        int size = nums.size();
        //由于 k 个列表都是升序排列的，因此对每个列表维护一个指针，
        //通过指针得到列表中的元素，指针右移之后指向的元素一定大于或等于之前的元素。
        int[] next = new int[size];
        //使用最小堆维护 k 个指针指向的元素中的最小值
        PriorityQueue<Integer> priorityQueue = new PriorityQueue<Integer>(new Comparator<Integer>() {
            public int compare(Integer index1, Integer index2) {
            	//第index个列表的next[index1]指针指向的元素
                return nums.get(index1).get(next[index1]) - nums.get(index2).get(next[index2]);
            }
        });
        
        for (int i = 0; i < size; i++) {
            //初始时，i 个指针都指向下标 0，因为next[i]=0
            priorityQueue.offer(i);
            //最大元素即为所有列表的下标 0 位置的元素中的最大值
            max = Math.max(max, nums.get(i).get(0));
        }
        
        while (true) {
            //每次从堆中取出最小值，minIndex是指第几个列表，也代表指针数组next的下标
            int minIndex = priorityQueue.poll();
            //根据最大值和最小值计算当前区间
            int curRange = max - nums.get(minIndex).get(next[minIndex]);
            //如果当前区间小于最小区间则用当前区间更新最小区间
            if (curRange < minRange) {
                minRange = curRange;
                rangeLeft = nums.get(minIndex).get(next[minIndex]);
                rangeRight = max;
            }
            //然后将对应列表的指针右移
            next[minIndex]++;
            //如果一个列表的指针超出该列表的下标范围，则说明该列表中的所有元素都被遍历过，
            //堆中不会再有该列表中的元素，因此退出循环。
            if (next[minIndex] == nums.get(minIndex).size()) {
                break;
            }
            //将新元素加入堆中
            priorityQueue.offer(minIndex);
            //并更新堆中元素的最大值
            max = Math.max(max, nums.get(minIndex).get(next[minIndex]));
        }
        return new int[]{rangeLeft, rangeRight};
    }
}

2. 滑动窗口+哈希表

复杂度

  public int[] smallestRange(List<List<Integer>> nums) {
        int size = nums.size();
        Map<Integer, List<Integer>> indices = new HashMap<Integer, List<Integer>>();
        int xMin = Integer.MAX_VALUE, xMax = Integer.MIN_VALUE;
        for (int i = 0; i < size; i++) {
            for (int x : nums.get(i)) {
                //Map.getOrDefault(Object key, V defaultValue)方法的作用是：
  //（1）当Map集合中存在这个key时，就使用这个key值,(若是数值型可以在此基础上进行运算)
 // （2）如果没有就使用默认值defaultValue。
                List<Integer> list = indices.getOrDefault(x, new ArrayList<Integer>());
                list.add(i);
                indices.put(x, list);
                xMin = Math.min(xMin, x);
                xMax = Math.max(xMax, x);
            }
        }

        int[] freq = new int[size];
        int inside = 0;
        int left = xMin, right = xMin - 1;
        int bestLeft = xMin, bestRight = xMax;

        while (right < xMax) {
            right++;
            if (indices.containsKey(right)) {
                for (int x : indices.get(right)) {
                    freq[x]++;
                    if (freq[x] == 1) {
                        inside++;
                    }
                }
                while (inside == size) {
                    if (right - left < bestRight - bestLeft) {
                        bestLeft = left;
                        bestRight = right;
                    }
                    if (indices.containsKey(left)) {
                        for (int x: indices.get(left)) {
                            freq[x]--;
                            if (freq[x] == 0) {
                                inside--;
                            }
                        }
                    }
                    left++;
                }
            }
        }

        return new int[]{bestLeft, bestRight};
    }

【总结】

1.滑动窗口核心思想

int left = 0, right = 0;

while (right < s.size()) {`
    // 增大窗口
    window.add(s[right]);
    right++;
    
    while (window needs shrink) {
        // 缩小窗口
        window.remove(s[left]);
        left++;
    }
}

2.Map-map.getOrDefault（）用法

为什么要用？
Map中在每个数据上进行累加我必须先给每个key赋初值才行 (如果不赋初值在计算一开始就会报空指针异常)

API

解释
Map.getOrDefault(Object key, V defaultValue)方法的作用是：
  （1）当Map集合中存在这个key时，就使用这个key值,(若是数值型可以在此基础上进行运算)
  （2）如果没有就使用默认值defaultValue

3.困难题目不在于思想的理解 而在于每句代码的理解

转载：https://leetcode-cn.com/problems/smallest-range-covering-elements-from-k-lists/solution/zui-xiao-qu-jian-by-leetcode-solution/
参考链接：https://blog.csdn.net/weixin_44325444/article/details/106306900?utm_medium=distribute.pc_relevant.none-task-blog-BlogCommendFromMachineLearnPai2-1.channel_param&depth_1-utm_source=distribute.pc_relevant.none-task-blog-BlogCommendFromMachineLearnPai2-1.channel_param