每日一题(小根堆)-1851. 包含每个查询的最小区间

题目

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

题解思路

• 求满足query在区间内的最小区间长度

1. 将[query, i]按从小到大排序
2. 将intervals按照起点长度从小到大排序
3. 建立小根堆，堆中存入（区间长度，以及区间结束点）

基于上述条件

1. 定义变量i，遍历排序之后的query
2. 当 i 小于区间数组的长度以及区间起点小于 query 时候，我们将（区间长度，区间终点）入堆
3. 当堆不为空时，且堆顶元素的区间终点小于当前查询的q时，我们将堆顶元素弹出
4. 当经过2、3步骤之后，满足的堆顶元素，即为我们所求的答案

代码

C++

class Solution {
public:
    vector<int> minInterval(vector<vector<int>>& intervals, vector<int>& queries) {
        int n = queries.size();
        vector<int> ans(n, -1);
        vector<pair<int, int>> querieswithidx(n);
        for(int i = 0; i < n; i++){
            querieswithidx[i].first = queries[i];
            querieswithidx[i].second = i;
        }
        sort(intervals.begin(), intervals.end());
        sort(querieswithidx.begin(), querieswithidx.end());

        priority_queue<pair<int, int>> heap;

        int i = 0;
        for(int j = 0; j < n; j++){
            int v = querieswithidx[j].first;
            int idx = querieswithidx[j].second;
            while (i < intervals.size() && intervals[i][0] <= v){
                int start = intervals[i][0];
                int end = intervals[i][1];
                int lenth = end - start + 1;
                pair<int, int> t(-lenth, -end);
                heap.push(t);
                i++;
            }
            while ( !heap.empty() && - heap.top().second < v){
                heap.pop();
            }
            if (!heap.empty()){
                ans[idx] = - heap.top().first;
            }
        }
        return ans;
    }
};

Python

class Solution:
    def minInterval(self, intervals: List[List[int]], queries: List[int]) -> List[int]:
        sorted_intervals = sorted(intervals, key = lambda x : x[0])
        sorted_queries = sorted(enumerate(queries), key = lambda x : x[1])
        
        intervals_heap = []
        result = [-1] * len(queries)

        i = 0 
        for idx, v in sorted_queries:
            while i < len(sorted_intervals) and sorted_intervals[i][0] <= v:
                start, end = sorted_intervals[i]
                lenth = end - start + 1
                heapq.heappush(intervals_heap, (lenth, end))
                i += 1
            while intervals_heap and intervals_heap[0][1] < v:
                heapq.heappop(intervals_heap)
            
            if intervals_heap:
                result[idx] = intervals_heap[0][0]

        return result

注意事项

c++ 中的访问pair时候，要使用pair.first， pair.second

c++ 可以将大根堆的元素取反 来实现小根堆