Minimum Interval to Include Each Query

# Python
import heapq

def minInterval(intervals, queries):
    intervals.sort()
    sorted_q = sorted(enumerate(queries), key=lambda x: x[1])
    result = [-1] * len(queries)
    heap = []  # (length, end)
    i = 0
    for idx, q in sorted_q:
        while i < len(intervals) and intervals[i][0] <= q:
            l, r = intervals[i]
            heapq.heappush(heap, (r - l + 1, r))
            i += 1
        while heap and heap[0][1] < q:
            heapq.heappop(heap)
        if heap:
            result[idx] = heap[0][0]
    return result

// C++
vector<int> minInterval(vector<vector<int>>& intervals, vector<int>& queries) {
    sort(intervals.begin(), intervals.end());
    int n = queries.size();
    vector<int> idx(n); iota(idx.begin(),idx.end(),0);
    sort(idx.begin(),idx.end(),[&](int a,int b){return queries[a]<queries[b];});
    priority_queue<pair<int,int>,vector<pair<int,int>>,greater<>> minH; // (len,end)
    vector<int> res(n,-1);
    int i=0;
    for (int qi : idx) {
        int q = queries[qi];
        while(i<(int)intervals.size()&&intervals[i][0]<=q){minH.push({intervals[i][1]-intervals[i][0]+1,intervals[i][1]});i++;}
        while(!minH.empty()&&minH.top().second<q)minH.pop();
        if(!minH.empty())res[qi]=minH.top().first;
    }
    return res;
}

// Java
public int[] minInterval(int[][] intervals, int[] queries) {
    Arrays.sort(intervals, (a,b)->a[0]-b[0]);
    int n=queries.length;
    Integer[] idx=new Integer[n]; for(int i=0;i<n;i++)idx[i]=i;
    Arrays.sort(idx,(a,b)->queries[a]-queries[b]);
    PriorityQueue<int[]>minH=new PriorityQueue<>(Comparator.comparingInt(a->a[0]));
    int[]res=new int[n]; Arrays.fill(res,-1); int i=0;
    for(int qi:idx){int q=queries[qi];
        while(i<intervals.length&&intervals[i][0]<=q){minH.offer(new int[]{intervals[i][1]-intervals[i][0]+1,intervals[i][1]});i++;}
        while(!minH.isEmpty()&&minH.peek()[1]<q)minH.poll();
        if(!minH.isEmpty())res[qi]=minH.peek()[0];
    }
    return res;
}

// JavaScript
function minInterval(intervals, queries) {
    intervals.sort((a,b)=>a[0]-b[0]);
    const n=queries.length;
    const idx=[...Array(n).keys()].sort((a,b)=>queries[a]-queries[b]);
    const heap=[]; // [len, end] sorted by len
    const res=Array(n).fill(-1); let i=0;
    for(const qi of idx){const q=queries[qi];
        while(i<intervals.length&&intervals[i][0]<=q){
            const[l,r]=intervals[i++];const len=r-l+1;
            let pos=heap.findIndex(x=>x[0]>=len); if(pos===-1)heap.push([len,r]);else heap.splice(pos,0,[len,r]);
        }
        while(heap.length&&heap[0][1]<q)heap.shift();
        if(heap.length)res[qi]=heap[0][0];
    }
    return res;
}