【Leetcode算法】Minimum Interval to Include Each Query 包含每个查询的最小区间

Minimum Interval to Include Each Query 包含每个查询的最小区间

问题描述：

给你一个二维整数数组 intervals ，其中 intervals[i] = $[lef{t}_i,righ{t}_i]$ 表示第 i 个区间开始于 $lef{t}_i$ 、结束于 $righ{t}_i$（包含两侧取值，闭区间）。区间的 长度 定义为区间中包含的整数数目，更正式地表达是 $righ{t}_i-lef{t}_i+1$ 。

再给你一个整数数组 queries 。第 j 个查询的答案是满足 $lef{t}_i<=queries[j]<=righ{t}_i$ 的 长度最小区间 i 的长度 。如果不存在这样的区间，那么答案是 -1 。

以数组形式返回对应查询的所有答案

$$\begin{gathered} 1<=intervals.length<=10^5 \\ 1<=queries.length<=10^5 \\ intervals[i].length==2 \\ 1<=lef{t}_i<=righ{t}_i<=10^7 \\ 1<=queries[j]<=10^7 \end{gathered}$$

分析

区间的规模最大$10^5$，通常的思路，进行一次查询，必然就是遍历，与每个区间都进行比较，记录下符合条件的区间的下标，并且在过程中找到最小。

单次的时间复杂度就是$O(N)$,而queries的规模最大也是$10^5$,所以很明显TLE.

如果对$interval$进行排序，以left从低到高进行排序，时间复杂度$O(NlogN)$,每次查找到最后1个符合条件的位置$idx$，即$0\to idx$，都是符合$left<=queries[i]$,只需要在这个范围内进行遍历即可，单次的时间复杂度$O(logN+M)$.

但是在最差的情况下，依然会达到$O(MN)$.

其实这个思路缺少了一个环节，如果每次查询后，可以缩小后续查询的范围，就可以有加速的效果。

将queries也排序从小到大，interval以left递增，并且以区间的大小从小到大排序。
对于$queries[i]$,将$0\to idx$,都满足$left<=queries[i]$,入优先队列。此时队列中都是left符合条件，并且区间最小的区间，但是不能保证$right>=queries[i]$,所以需要将队首元素进行验证，如果 $right<queries[i]$,可以直接出队，因为$right<queries[i]$,一定也$right<queries[j]$.

因为queries是按照顺序出结果，所以需要记录queries的原来的顺序，然后进行索引排序。

代码

 class Solution {
    public int[] minInterval(int[][] intervals, int[] queries) {
        Integer[] qindex = new Integer[queries.length];
        for (int i = 0; i < queries.length; i++) {
            qindex[i] = i;
        }
        Arrays.sort(qindex, (i, j) -> queries[i] - queries[j]);
        Arrays.sort(intervals, (i, j) -> i[0] - j[0]);
        // scope,left,right
        PriorityQueue<int[]> pq = new PriorityQueue<int[]>((a, b) -> a[0] - b[0]);
        int[] res = new int[queries.length];
        Arrays.fill(res, -1);
        int i = 0;
        for (int qi : qindex) {
            while (i < intervals.length && intervals[i][0] <= queries[qi]) {
                pq.offer(new int[]{intervals[i][1] - intervals[i][0] + 1, intervals[i][0], intervals[i][1]});
                i++;
            }
            while (!pq.isEmpty() && pq.peek()[2] < queries[qi]) {
                pq.poll();
            }
            if (!pq.isEmpty()) {
                res[qi] = pq.peek()[0];
            }
        }
        return res;
    }
} 

时间复杂度$O(M\log M+N\log N)$

空间复杂度$O(M+N)$

Tag

Array

Sorting

Priority Queue