1851. 包含每个查询的最小区间

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

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

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

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/minimum-interval-to-include-each-query
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

import java.util.Arrays;
import java.util.Comparator;
import java.util.PriorityQueue;

class Solution {
    public int[] minInterval(int[][] intervals, int[] queries) {
        Arrays.sort(intervals, (o1, o2) -> Integer.compare(o1[0], o2[0]));
        int[][] queryEnriches = new int[queries.length][2];
        for (int i = 0; i < queries.length; ++i) {
            queryEnriches[i][0] = queries[i];
            queryEnriches[i][1] = i;
        }
        Arrays.sort(queryEnriches, (o1, o2) -> Integer.compare(o1[0], o2[0]));
        PriorityQueue<int[]> queue = new PriorityQueue<>(new Comparator<int[]>() {
            @Override
            public int compare(int[] o1, int[] o2) {
                return Integer.compare(o1[1] - o1[0], o2[1] - o2[0]);
            }
        });
        int[] ans = new int[queries.length];
        Arrays.fill(ans, -1);
        int index = 0;
        for (int i = 0; i < queryEnriches.length; ++i) {
            while (index < intervals.length && intervals[index][0] <= queryEnriches[i][0]) {
                queue.offer(intervals[index++]);
            }

            while (!queue.isEmpty() && queue.peek()[1] < queryEnriches[i][0]) {
                queue.poll();
            }
            if (!queue.isEmpty()) {
                int[] node = queue.peek();
                ans[queryEnriches[i][1]] = node[1] - node[0] + 1;
            }
        }
        return ans;
    }
}