【LeetCode】每日一题（二十六）632. 最小区间 滑动窗口+哈希表 / 堆

632. 最小区间

20200801

难度：困难

题目描述

你有 k 个升序排列的整数数组。找到一个最小区间，使得 k 个列表中的每个列表至少有一个数包含在其中。

我们定义如果 b-a < d-c 或者在 b-a == d-c 时 a < c，则区间 [a,b] 比 [c,d] 小。

示例 1:

输入:[[4,10,15,24,26], [0,9,12,20], [5,18,22,30]]
输出: [20,24]
解释: 
列表 1：[4, 10, 15, 24, 26]，24 在区间 [20,24] 中。
列表 2：[0, 9, 12, 20]，20 在区间 [20,24] 中。
列表 3：[5, 18, 22, 30]，22 在区间 [20,24] 中。

注意:

1. 给定的列表可能包含重复元素，所以在这里升序表示 >= 。
2. 1 <= k <= 3500
3. -105 <= 元素的值 <= 105

Solution

1. 小根堆

   该问题可以转化为，从 k 个列表中各取一个数，使得这 k 个数中的最大值与最小值的差最小。

   使用最小堆维护 k 个指针指向的元素中的最小值，同时维护堆中元素的最大值。初始时，k 个指针都指向下标 0，最大元素即为所有列表的下标 0 位置的元素中的最大值。每次从堆中取出最小值，根据最大值和最小值计算当前区间，如果当前区间小于最小区间，则用当前区间更新最小区间，然后将对应列表的指针右移，将新元素加入堆中，并更新堆中元素的最大值。如果一个列表的指针超出该列表的下标范围，则说明该列表中的所有元素都被遍历过，堆中不会再有该列表中的元素，因此退出循环。

class Solution {
    public int[] smallestRange(List<List<Integer>> nums) {
        int leftRange = 0;
        int rightRange = Integer.MAX_VALUE;
        int minRange = rightRange - leftRange;//最小区间长度
        int max = Integer.MIN_VALUE;//区间左边的最大值 堆中元素对应的值的最大值
        int size = nums.size();
        int[] next = new int[size];// 每个列表维护一个指针,初始时i个指针都指向下标 0，next[i]=0
        //小根堆
        PriorityQueue<Integer> pq = new PriorityQueue<>(new Comparator<Integer>(){
            public int compare(Integer index1, Integer index2){
                //比较的是第index个列表的next[index]指针指向的元素
                return nums.get(index1).get(next[index1]) - nums.get(index2).get(next[index2]);
            }
        });

        for(int i = 0; i < size; i++){
            //堆中加的是第几个列表 是列表索引
            pq.offer(i);
            // 所有列表的下标 0 位置的元素中的最大值
            max = Math.max(max, nums.get(i).get(0));
        }

        while(true){
            int minIndex = pq.poll();//从堆中取出"最小值"对应的列表索引
            // 根据最大值和最小值计算当前区间
            int curRange = max - nums.get(minIndex).get(next[minIndex]);
            if(curRange < minRange){
                minRange = curRange;
                leftRange = nums.get(minIndex).get(next[minIndex]);
                rightRange = max;
            }
            next[minIndex]++;// 对应列表的指针右移
            // 如果有一个列表的指针超出该列表的下标范围
            if(next[minIndex] == nums.get(minIndex).size()){
                break;
            }
            pq.offer(minIndex);
            // 更新堆中元素的"最大值"
            max = Math.max(max, nums.get(minIndex).get(next[minIndex]));
        }
        return new int[]{leftRange, rightRange};
    }
}

2. 哈希表+滑动窗口

   参考76题

   以原来数字的最小值和最大值为界，用两个指针圈定一个活动的窗口，去捕获目标数字。找齐每个数组的数字，必须知道各个数字来自哪个数组。记录每个数字来自哪个列表，数字会有重复，一个数字可以来自多个列表。

   窗口扩张，count 记录当前窗口包含了几个数组的数字，当纳入了一个正好缺失的数组的数字，count就+1 。count==k就是找到了可行解，这时候缩小左边界，直到条件不再满足。记录当前最优解，然后再继续扩张，寻找下一个可行解。

class Solution {
    public int[] smallestRange(List<List<Integer>> nums) {
        int size = nums.size();
        Map<Integer, List<Integer>> map = new HashMap<>();
        int xMin = Integer.MAX_VALUE, xMax = Integer.MIN_VALUE;
        for(int i = 0; i < size; i++){
            //记录每个数字来自哪个列表，数字会有重复，一个数字可以来自多个列表
            for(int j = 0; j < nums.get(i).size(); j++){
                int num = nums.get(i).get(j);
                List<Integer> tmp = map.getOrDefault(num, new ArrayList<>());
                tmp.add(i);
                map.put(num, tmp);
                xMin = Math.min(xMin, num);
                xMax = Math.max(xMax, num);
            }
        }
        int min= Integer.MAX_VALUE;//最小区间长度
        int l = xMin, r = xMin - 1;//窗口左右边界 表示值
        int count = 0;//当前窗口包含了几个列表的数字,count=size才符合
        int start = l, end = r;
        int[] freq = new int[size];//每个列表现在有几个数字了 
        while(r < xMax){
            r++;
            if(map.containsKey(r)){
                for(int x : map.get(r)){//当前数字出现在哪些列表中
                    if(freq[x] == 0){//纳入了一个正好缺失的列表的数字
                        count++;
                    }
                    freq[x]++;//列表x的对应出现次数+1
                }
                //找到可行解
                while(count == size){
                    if(r - l < min){
                        min = r - l;
                        start = l;
                        end = r;
                    }
                    //左边界收缩
                    //滑走的数字后，如果对应列表的出现次数减成0，count--
                    if(map.containsKey(l)){
                        for(int x : map.get(l)){
                            freq[x]--;
                            if(freq[x] == 0){
                                count--;
                            }
                        }
                    }
                    l++;
                }
            }
        }
        return new int[]{start, end};
    }
}

---

欢迎关注公众号：GitKid，暂时每日分享LeetCode题解，在不断地学习中，公众号内容也在不断充实，欢迎扫码关注