[leetcode]632. Smallest Range最小范围

You have k lists of sorted integers in ascending order. Find the smallest range that includes at least one number from each of the k lists.

We define the range [a,b] is smaller than range [c,d] if b-a < d-c or a < c if b-a == d-c.

Example 1:

Input:[[4,10,15,24,26], [0,9,12,20], [5,18,22,30]]
Output: [20,24]
Explanation: 
List 1: [4, 10, 15, 24,26], 24 is in range [20,24].
List 2: [0, 9, 12, 20], 20 is in range [20,24].
List 3: [5, 18, 22, 30], 22 is in range [20,24].

Note:

1. The given list may contain duplicates, so ascending order means >= here.
2. 1 <= k <= 3500
3. -105 <= value of elements <= 105.
4. For Java users, please note that the input type has been changed to List<List<Integer>>. And after you reset the code template, you'll see this point.

题意：

给定一些sorted array, 求一个最小范围，使得该范围内至少包含每个数组中的一个数字。

思路：

这个题来自打车公司lyft，现实意义是模拟该app在很多user登陆的登陆时间，narrow一个范围，这样就可以在user登陆时间最频繁的范围里投放广告或者做些其他的商业行为。

two pointer的思路。

三个指针zero、first、second同时从每个list的首元素出发。用pointerIndex来维护一个数组记录每个list当前指针的index。

比较三个指针对应的元素大小。记录比较后的curMin, curMax，更新smallest range。 

移动curMin对应的指针，比较三个指针对应的元素大小。记录比较后的curMin, curMax，更新smallest range。 更新pointerIndex。

直至curMin对应的指针无法移动为止（即curMin走到了某个list的尽头）。

[4,10,15,24,26]
 ^
zero

[0,9,12,20]
 ^
first

[5,18,22,30]
 ^
second

                                                      curMin        curMax         range          pointerIndex

                                                                                                              zero|first|second

init                                                    0                  5                 5              0  |  0  |  0 

curMin对应的指针first++                       4                  9                 5              0  |  1  |  0 

curMin对应的指针zero++                       5                 10                5               1  |  1  |  0 

curMin对应的指针second++                   9                 18                9               1  |  1  |  1 

curMin对应的指针first++                       10                18                8               1  |  2  |  1 

curMin对应的指针zero++                      12                 18               6                2  |  2  |  1 

curMin对应的指针first++                       15                20               5                2  |  3  |  1

curMin对应的指针zero++                      18                24                6                3  |  3  |  1 

curMin对应的指针second++                 20                 24                4                3  |  3  |  2

代码一：

 public int[] smallestRange2(List<List<Integer>> nums) {
        int curMin = 0;
        int curMax = Integer.MAX_VALUE;
        int[] pointerIndex = new int[nums.size()];// maintain一个数组来记录每层list当前的pointer的index
        boolean flag = true;  // flag辅助判断是否有某个list走到了末尾

        for (int i = 0; i < nums.size() && flag; i++) { // 外层循环遍历list
            for (int j = 0; j < nums.get(i).size() && flag; j++) { // 内层循环遍历某个list的第 j 个元素
                int minValueLevel = 0;
                int maxValueLevel = 0;
                for (int k = 0; k < nums.size(); k++) {
                    if (nums.get(minValueLevel).get(pointerIndex[minValueLevel]) > nums.get(k).get(pointerIndex[k])) {
                        minValueLevel = k;
                    }
                    if (nums.get(maxValueLevel).get(pointerIndex[maxValueLevel]) < nums.get(k).get(pointerIndex[k])) {
                        maxValueLevel = k;
                    }
                }
                // 是否更新smallest range
                if (nums.get(maxValueLevel).get(pointerIndex[maxValueLevel]) - nums.get(minValueLevel).get(pointerIndex[minValueLevel]) < curMax - curMin) {
                    curMin = nums.get(minValueLevel).get(pointerIndex[minValueLevel]);
                    curMax = nums.get(maxValueLevel).get(pointerIndex[maxValueLevel]);
                }
                // 移动当前找到的最小值对应的pointer
                pointerIndex[minValueLevel]++;
                // flag辅助判断是否有某个list走到了末尾
                if (pointerIndex[minValueLevel] == nums.get(minValueLevel).size()) {
                    flag = false;
                    break;
                }

            }
        }
        return new int[]{curMin, curMax};
    }

这个代码在oj上显示time limit exceeded

因为每次都要比较三个指针对应元素的curMin和curMax,  我们可以用一个PriorityQueue来优化。

PriorityQueue里面存放当前三个指针对应的元素。

PriorityQueue 删除极值的时间复杂度是 O(logN), 查找极值的时间复杂度是 O(1)

能够在时间上进行优化。

代码二：

  public int[] smallestRange(List<List<Integer>> nums) {
        int curMin = 0;
        int curMax = Integer.MAX_VALUE;
        int max = Integer.MIN_VALUE;
        int[] pointerIndex = new int[nums.size()];
        boolean flag = true;
        PriorityQueue<Integer> queue = new PriorityQueue<Integer>((i, j) -> nums.get(i).get(pointerIndex[i]) - nums.get(j).get(pointerIndex[j]));
        for (int i = 0; i < nums.size(); i++) {
            queue.add(i);
            max = Math.max(max, nums.get(i).get(0));
        }
        for (int i = 0; i < nums.size() && flag; i++) {
            for (int j = 0; j < nums.get(i).size() && flag; j++) {
                int minValueLevel = queue.poll();
                // 是否更新smallest range
                if (max - nums.get(minValueLevel).get(pointerIndex[minValueLevel]) < curMax - curMin) {
                    curMin = nums.get(minValueLevel).get(pointerIndex[minValueLevel]);
                    curMax = max;
                }
                // 移动当前找到的最小值对应的pointer
                pointerIndex[minValueLevel]++;
                // flag辅助判断是否有某个list走到了末尾
                if (pointerIndex[minValueLevel] == nums.get(minValueLevel).size()) {
                    flag = false;
                    break;
                }
                queue.offer(minValueLevel);
                max = Math.max(max, nums.get(minValueLevel).get(pointerIndex[minValueLevel]));

            }
        }
        return new int[]{curMin, curMax};
    }