Minimum Interval to Include Each Query - Practice Coding Problems

Minimum Interval to Include Each Query - Problem

Array Binary Search Line Sweep Sorting Heap (Priority Queue) Hard

Imagine you're managing a library with time-sensitive book reservations. You have multiple reservation intervals, and patrons are making queries about when they can access books. Your job is to find the shortest reservation period that covers each patron's requested time.

You are given a 2D integer array intervals, where intervals[i] = [left_i, right_i] represents the i-th time interval starting at left_i and ending at right_i (inclusive). The size of an interval is defined as the number of time units it contains: right_i - left_i + 1.

You are also given an integer array queries. For each query queries[j], you need to find the smallest interval that contains this query point. If no such interval exists, return -1.

Goal: Return an array containing the sizes of the smallest intervals for each query, or -1 if no interval contains the query.

Input & Output

example_1.py — Basic Case

$ Input: intervals = [[1,4],[2,4],[3,6],[4,4]], queries = [2,3,4,5]

› Output: [3,3,1,4]

💡 Note: Query 2: contained in [1,4] (size 3) and [2,4] (size 3), minimum is 3. Query 3: contained in [1,4], [2,4], [3,6], minimum size is 3. Query 4: contained in [1,4], [2,4], [3,6], [4,4], minimum size is 1 from [4,4]. Query 5: only contained in [3,6] (size 4).

example_2.py — No Valid Intervals

$ Input: intervals = [[2,3],[2,5],[1,8],[20,25]], queries = [2,19,5,22]

› Output: [2,-1,4,6]

💡 Note: Query 2: contained in [2,3] (size 2), [2,5] (size 4), [1,8] (size 8), minimum is 2. Query 19: not contained in any interval, return -1. Query 5: contained in [2,5] (size 4) and [1,8] (size 8), minimum is 4. Query 22: only contained in [20,25] (size 6).

example_3.py — Single Point Intervals

$ Input: intervals = [[1,1],[2,2],[3,3]], queries = [1,2,3,4]

› Output: [1,1,1,-1]

💡 Note: Each interval contains exactly one point and has size 1. Query 4 is not contained in any interval, so returns -1.

Visualization

Tap to expand

Understanding the Visualization

Sort Everything

Sort queries by time and intervals by start time for efficient processing

Process in Order

For each query time, add all intervals that have started to our 'available books' heap

Clean Expired

Remove any intervals that have ended before the current query time

Find Best Option

The top of the min-heap gives us the shortest available reservation period

Key Takeaway

🎯 Key Insight: By processing queries in sorted order and maintaining active intervals in a min-heap, we avoid redundant work and achieve optimal O((n+m) log n) complexity.

Time & Space Complexity

Time Complexity

⏱️

O(n × m)

For each of the m queries, we check all n intervals

✓ Linear Growth

Space Complexity

O(1)

Only using a few variables to track minimum size

✓ Linear Space

Constraints

1 ≤ intervals.length ≤ 10⁵
1 ≤ queries.length ≤ 10⁵
intervals[i].length == 2
1 ≤ left_i ≤ right_i ≤ 10⁷
1 ≤ queries[j] ≤ 10⁷
Large input sizes require efficient O(n log n) solution

Asked in

G Google 42 a Amazon 38 f Meta 31 ⊞ Microsoft 28 🍎 Apple 19

The optimal solution uses sorting and priority queue (min-heap) to efficiently process queries. By sorting both queries and intervals, then using a heap to track the smallest active intervals, we achieve O((n+m) log n) time complexity. The key insight is processing queries in sorted order while maintaining active intervals in a min-heap ordered by size.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Check All Intervals)	O(n × m)	O(1)	For each query, check all intervals and find the smallest one that contains it
Sorting + Priority Queue (Optimal)	O((n + m) log n)	O(n + m)	Sort queries and intervals, use min-heap to efficiently track smallest active intervals

Brute Force (Check All Intervals) — Algorithm Steps

For each query in the queries array
Iterate through all intervals
Check if the current interval contains the query (left <= query <= right)
Track the minimum size among all containing intervals
Return the minimum size, or -1 if no interval contains the query

Visualization

Tap to expand

Step-by-Step Walkthrough

Process Query 2

Check intervals [1,4], [2,4], [3,6], [4,4] - find [1,4] and [2,4] contain 2

Find Minimum

Among containing intervals, [1,4] and [2,4] both have size 3

Repeat Process

Repeat the same process for each remaining query

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <limits.h>

int* minInterval(int** intervals, int intervalsSize, int* intervalColSize, int* queries, int queriesSize, int* returnSize) {
    *returnSize = queriesSize;
    int* result = (int*)malloc(queriesSize * sizeof(int));
    
    for (int i = 0; i < queriesSize; i++) {
        int query = queries[i];
        int minSize = INT_MAX;
        int found = 0;
        
        for (int j = 0; j < intervalsSize; j++) {
            int left = intervals[j][0], right = intervals[j][1];
            if (left <= query && query <= right) {
                found = 1;
                int size = right - left + 1;
                if (size < minSize) {
                    minSize = size;
                }
            }
        }
        
        result[i] = found ? minSize : -1;
    }
    
    return result;
}

int main() {
    // Parse input and call solution
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n × m)

For each of the m queries, we check all n intervals

✓ Linear Growth

Space Complexity

O(1)

Only using a few variables to track minimum size

✓ Linear Space

Constraints

1 ≤ intervals.length ≤ 10⁵
1 ≤ queries.length ≤ 10⁵
intervals[i].length == 2
1 ≤ left_i ≤ right_i ≤ 10⁷
1 ≤ queries[j] ≤ 10⁷
Large input sizes require efficient O(n log n) solution

78.3K Views

High Frequency

~25 min Avg. Time

1.8K Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Brute Force (Check All Intervals) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler