Minimum Interval to Include Each Query

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.

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

Visualization

Tap to expand

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

✓ Brute Force (Check All Intervals)

⏱️ Time: O(n × m) Space: O(1)

The straightforward approach: for each query point, iterate through all intervals to find those that contain the query, then return the size of the smallest such interval.

Sorting + Priority Queue (Optimal)

⏱️ Time: O((n + m) log n) Space: O(n + m)

The optimal approach uses sorting and a priority queue (min-heap). We sort both queries and intervals, then process queries in order while maintaining active intervals in a min-heap ordered by size.

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>
#include <string.h>

int* minInterval(int** intervals, int intervalsSize, int* intervalsColSize, 
                 int* queries, int queriesSize, int* returnSize) {
    
    int* result = (int*)malloc(queriesSize * sizeof(int));
    *returnSize = queriesSize;
    
    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];
            int right = intervals[j][1];
            
            if (query >= left && query <= right) {
                found = 1;
                int size = right - left + 1;
                
                if (size < minSize) {
                    minSize = size;
                }
            }
        }
        
        result[i] = found ? minSize : -1;
    }
    
    return result;
}

int main() {
    char line[10000];
    
    fgets(line, sizeof(line), stdin);
    char* ptr = strchr(line, '[');
    
    int intervalsSize = 0;
    int** intervals = (int**)malloc(1000 * sizeof(int*));
    
    ptr++;
    while (*ptr != ']') {
        if (*ptr == '[') {
            intervals[intervalsSize] = (int*)malloc(2 * sizeof(int));
            sscanf(ptr, "[%d,%d]", &intervals[intervalsSize][0], &intervals[intervalsSize][1]);
            intervalsSize++;
            while (*ptr != ']') ptr++;
            ptr++;
        } else {
            ptr++;
        }
    }
    
    fgets(line, sizeof(line), stdin);
    ptr = strchr(line, '[');
    
    int queriesSize = 0;
    int* queries = (int*)malloc(1000 * sizeof(int));
    
    ptr++;
    while (*ptr != ']') {
        if (*ptr >= '0' && *ptr <= '9') {
            queries[queriesSize++] = atoi(ptr);
            while (*ptr >= '0' && *ptr <= '9') ptr++;
        } else {
            ptr++;
        }
    }
    
    int returnSize;
    int colSize = 2;
    int* result = minInterval(intervals, intervalsSize, &colSize, 
                              queries, queriesSize, &returnSize);
    
    printf("[");
    for (int i = 0; i < returnSize; i++) {
        printf("%d", result[i]);
        if (i < returnSize - 1) printf(",");
    }
    printf("]\n");
    
    for (int i = 0; i < intervalsSize; i++) free(intervals[i]);
    free(intervals);
    free(queries);
    free(result);
    
    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

78.4K 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

Constraints

Visualization

Related Problems

Common Approaches

Brute Force (Check All Intervals) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler