Leetcode 632

给定k个递增的列表

找到最短的区间包含这k个列表里每个列表至少一个数

 

 

贪心地去想，显然这k个数相邻越近，数字越小。那么我们首先拿k个列表最小数，看看答案是多少（最大值-最小值就是答案），然后把最小那个数逐次增大，比如这个数是第一个列表第一个数，那么就替换第一个列表第二个数，然后判答案是否更优，依次比下去。

实现的话可以采用heap维护一个大小为k的堆来做

    public int[] smallestRange(List<List<Integer>> nums) {
        PriorityQueue<Node> pq = new PriorityQueue<>(new Comparator<Node>() {
            @Override
            public int compare(Node o1, Node o2) {
                return Integer.compare(o1.val, o2.val);
            }
        });
        int len = nums.size();
        int res = Integer.MAX_VALUE;

        //当前队列里的最大值
        int max = Integer.MIN_VALUE;
        int minNum = Integer.MIN_VALUE;
        int maxNum = Integer.MIN_VALUE;
        for (int i = 0; i < len; i++) {
            int x = nums.get(i).get(0);
            pq.add(new Node(i, 0, x));
            max = Math.max(max, x);
        }

        while (pq.size() == len) {
            Node mi = pq.poll();
            if (max - mi.val < res) {
                res = max - mi.val;
                minNum = mi.val;
                maxNum = max;
            }
            if (mi.index < nums.get(mi.group).size() - 1) {
                int x = nums.get(mi.group).get(mi.index + 1);
                pq.add(new Node(mi.group, mi.index + 1, x));
                max = Math.max(max, x);
            }
        }
        return new int[]{minNum, maxNum};
    }


    class Node {
        int group;
        int index;
        int val;

        public Node(int group, int index, int val) {
            this.group = group;
            this.index = index;
            this.val = val;
        }
    }