LeetCode 632. 最小区间

LeetCode 632. 最小区间

題目

	632. 最小区间
你有 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 <= k <= 3500
-105 <= 元素的值 <= 105
对于使用Java的用户，请注意传入类型已修改为List>。重置代码模板后可以看到这项改动。
通过次数12,050提交次数20,829

思路

友情链接 [LeetCode 合并多个链表](https://blog.csdn.net/qq_42499133/article/details/105889948)
这道题的意思是，找到一个最短区间，区间中的值是包含所有数组中的值。
难点：如何找到最短的区间？
答：将每个数组视为升序链表，共有n个，用优先队列存储最小的链表头节点，每取出一个头节点，就判断当前节点与
最大值之差(max-tmpValue +1) 是否比过去的长度短，**因为用了一个max记录最大需要值，并且取出的node值最
小（要么让区间减小，要么区间不变，不变的原因是因为在这一步之前的max发生了变化，只要链表往后面走，tmp
Value增加，区间段肯定是在缩小的，本质上还是暴力枚举，不过节省消耗），所以更新left会使得当前left和r
ight满足所有数组均在区间中这一条件。**
如果取出的最小值，还比max大呢？那么过去的状态max不满足所有数字在其中，我们要将max的值变为node值

代码

我绝望了，提交了一次，然后看其他人写的very very good，想优化，结果结构体优化把我搞死了，直接借用大佬
的代码

import java.util.*;
public class 最小区间2 {
	class NumGroup{
        public NumGroup(int num, int grp){
            this.num = num;
            this.grp = grp;
        }
        int num; //数值
        int grp; //组号
    }
    public int[] smallestRange(List<List<Integer>> nums) {
        //因为每次都要找最小元素，所以维护一个最小堆比较合适
        PriorityQueue<NumGroup> numgrp = new PriorityQueue<>(new Comparator<NumGroup>(){
            @Override 
            public int compare(NumGroup n1, NumGroup n2){
                return n1.num - n2.num;
            }
        });

        int end =Integer.MIN_VALUE;
        int[] index = new int[nums.size()];
        //起始区间
        for(int i = 0; i < nums.size(); i++){
            if(nums.get(i).get(0) > end) end = nums.get(i).get(0);
            NumGroup num = new NumGroup(nums.get(i).get(0), i);
            numgrp.offer(num);
        }

        int max = end;
        int start = numgrp.peek().num;
        int min = start;
        int len = end - start + 1;

        while(true){
            //grp为当前最小元素的原数组号
            int grp = numgrp.poll().grp;
            //如果当前最小元素已经是原数组最大元素了，则退出
            if(index[grp]+1 == nums.get(grp).size()) break;

            //索引++，并将当前最小元素的原数组中的下一个元素压入优先级队列
            index[grp]++;
            NumGroup n = new NumGroup(nums.get(grp).get(index[grp]), grp);
            numgrp.offer(n);
            //当前最大值
            if(n.num > max) max = n.num;
            min = numgrp.peek().num;
            //长度变小
            if(max-min+1 < len){
                start = min;
                end = max;
                len = max-min+1;
            }
        }

        return new int[]{start, end};
    }
}