算法题 二 之 最小区间

题目

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

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

例如：
输入：[[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] 中

翻译一下题目

• 给很多个数组，每个数组单调递增
• 需要返回一个最小区间，这个区间包含了所有数组里的至少一个数字
• 区间如果长度谁更短，谁的就是更小区间，如果长度一致，则起点谁更小

分析

那上述例子来进行分析

4 10 15 24 26
0 9 12 20
5 18 22 30

• 我们先考虑每个数组的第一个数字。假如说，输出的区间都包含了数组的第一个数字，那么很明显，区间等于所有数组的第一个数字的集合里的最小值min和最大值max组成的区间 在上述例子里，为 [0,5]
• 所以，目前的min = 0，max = 5。上述的操作，会保留三个指针，分别指向各自数组的第一个，也就是index1…size = 0
• 我们要缩短区间，可以使min 变大的幅度大于max 变大的幅度，

①：先建立一个最小堆，把列表的第一个数字都入堆，在入堆的过程中，记录min、max值，很明显 min 和 max 组合起来的区间，就是答案了。

②：那么现在问题转化成：如何去更新min、max值让去缩小区间？很显然，要不使min变大，要不max变小。而从题目里我们可以知道，每个列表都是单调递增的，所以，max是无法变小的（或者说，变小都是已经考虑过的情况）。

③：所以问题转化成，如何让min变大？首先，min值是处于某个列表里的，那么我们马上就可以反应到：我们可以使min值所在的下标往后移动一位。可能有同学会有疑问，这样子没有考虑到其他列表。解决这个问题，我们可以在min往后移动一位之前，把min出堆，移动一位之后，重新把移动的这一位入堆，然后在取到堆顶，重新设置min，这样子min值就都考虑到了每个列表。

④：什么时候可以判断 min、max是最小区间？min所在列表，已经走到底部了，就是最小区间了。因为当min为目前堆里最小并且是列表最大时，min值已经无法再次变大了。

附上代码

 public int[] smallestRange(List<List<Integer>> nums) {
        // 优先级队列
        PriorityQueue<Model> priorityQueue = new PriorityQueue<>(new Comparator<Model>() {
            @Override
            public int compare(Model o1, Model o2) {
                return o1.data - o2.data;
            }
        });
        int start = Integer.MAX_VALUE;
        int end = Integer.MIN_VALUE;

        int max = Integer.MIN_VALUE;

        for(int i = 0; i < nums.size(); i++){
            List<Integer> list = nums.get(i);
            if(list == null || list.size() == 0){
                return new int[0];
            }
            Integer value = list.get(0);
            start = Math.min(start,value);
            end = Math.max(end,value);
            priorityQueue.add(new Model(value,i,0));
            max = Math.max(max,value);
        }

        while(true){
            //出队最小
            Model model = priorityQueue.poll();
            int i = model.row;
            int j = model.k;
            j++;
            if(j < nums.get(i).size()){
                Model tempModel = new Model(nums.get(i).get(j), i, j);
                priorityQueue.add(tempModel);

                if(tempModel.data > max){
                    max = tempModel.data;
                }
                int min = priorityQueue.peek().data;
                if(max - min < end - start){
                    end = max;
                    start = min;
                } else if(max - min == end - start && min < start){
                    end = max;
                    start = min;
                }
            } else {//说明已经走到底了
                break;
            }
        }
        return new int[]{start,end};
    }

    public static class Model{
        int data;//数据
        int row;//位于第几个数组
        int k;//第几个数组的第几个

        public Model(int data, int row, int k) {
            this.data = data;
            this.row = row;
            this.k = k;
        }
    }