Smallest Range Covering Elements from K Lists

Smallest Range Covering Elements from K Lists - Problem

Array Hash Table Greedy Sliding Window Sorting Heap (Priority Queue) Hard

Smallest Range Covering Elements from K Lists

Imagine you're a data analyst trying to find the most efficient way to represent multiple datasets with a single range. You have k lists of sorted integers in non-decreasing order, and your goal is to find the smallest possible range [a, b] that includes at least one number from each of the k lists.

The challenge is in the definition of "smallest": Range [a, b] is smaller than range [c, d] if:
• b - a < d - c (shorter length wins), OR
• b - a == d - c AND a < c (same length, but starts earlier)

This problem tests your ability to work with multiple sorted sequences simultaneously and find optimal overlapping ranges.

Input & Output

example_1.py — Basic Case

$ Input: [[4,10,15,24,26],[0,9,12,20],[5,18,22,30]]

› Output: [20,24]

💡 Note: The range [20,24] includes 24 from list 1, 20 from list 2, and 22 from list 3. This gives us a range of size 4, which is optimal. Other ranges like [4,5] would have size 1 but don't include elements from all lists.

example_2.py — Single Element Lists

$ Input: [[1],[2],[3]]

› Output: [1,3]

💡 Note: When each list has only one element, we must include all of them. The range spans from the minimum (1) to the maximum (3), giving us [1,3] with size 2.

example_3.py — Overlapping Ranges

$ Input: [[1,2,3],[1,2,3],[1,2,3]]

› Output: [1,1]

💡 Note: Since all lists contain the same elements, we can pick the same value (1) from each list, giving us the optimal range [1,1] with size 0.

Constraints

nums.length == k
1 ≤ k ≤ 3500
1 ≤ nums[i].length ≤ 50
-10⁵ ≤ nums[i][j] ≤ 10⁵
nums[i] is sorted in non-decreasing order

Visualization

Tap to expand

Understanding the Visualization

Set Up Initial Window

Start with each band's first preferred date. This gives you k dates to work with.

Find Current Window

The current booking window spans from the earliest date to the latest date among your k selected dates.

Try to Shrink Window

The band with the earliest date is limiting your window. Try their next preferred date to potentially find a better window.

Update Best Window

If the new window is smaller, update your best booking window. Continue until no more dates are available.

Optimal Booking Found

You've found the shortest possible booking window that satisfies all bands!

Key Takeaway

🎯 Key Insight: The optimal range always has its boundaries at actual elements from the input lists. By using a min-heap to efficiently track the minimum while maintaining the maximum, we can explore all possible ranges in optimal time complexity.

Asked in

G Google 45 a Amazon 38 ⊞ Microsoft 32 f Meta 28

The optimal solution uses a min-heap with sliding window technique to efficiently find the smallest range. By maintaining one element from each list in the heap and tracking the maximum, we can explore all possible ranges in O(n log k) time where n is total elements and k is number of lists.

Common Approaches

Approach	Time	Space	Notes
✓ Min-Heap + Sliding Window (Optimal)	O(n * log k)	O(k)	Use a min-heap to efficiently find the smallest range by maintaining one element from each list
Brute Force (Try All Combinations)	O(n^k)	O(1)	Generate all possible combinations of picking one element from each list

Min-Heap + Sliding Window (Optimal) — Algorithm Steps

Initialize a min-heap with the first element from each list along with its list index
Track the current maximum among all elements in the heap
While heap is not empty, extract minimum element
Calculate current range (max - min) and update best range if better
Add the next element from the same list as the extracted minimum
Update maximum if the new element is larger
Continue until any list is exhausted

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize Heap

Add first element from each list to min-heap, track maximum

Extract Minimum

Pop smallest element, calculate current range (max - min)

Advance Pointer

Add next element from same list, update maximum if needed

Update Best Range

Keep track of smallest range found so far

Continue Until Done

Stop when any list is exhausted (can't maintain coverage)

Code -

solution.c — C

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

typedef struct {
    int value;
    int listIdx;
    int elemIdx;
} HeapItem;

typedef struct {
    HeapItem* items;
    int size;
    int capacity;
} MinHeap;

MinHeap* createHeap(int capacity) {
    MinHeap* heap = malloc(sizeof(MinHeap));
    heap->items = malloc(capacity * sizeof(HeapItem));
    heap->size = 0;
    heap->capacity = capacity;
    return heap;
}

void heapifyUp(MinHeap* heap, int index) {
    while (index > 0) {
        int parent = (index - 1) / 2;
        if (heap->items[parent].value <= heap->items[index].value) break;
        
        HeapItem temp = heap->items[parent];
        heap->items[parent] = heap->items[index];
        heap->items[index] = temp;
        index = parent;
    }
}

void heapifyDown(MinHeap* heap, int index) {
    while (1) {
        int smallest = index;
        int left = 2 * index + 1;
        int right = 2 * index + 2;
        
        if (left < heap->size && heap->items[left].value < heap->items[smallest].value) {
            smallest = left;
        }
        if (right < heap->size && heap->items[right].value < heap->items[smallest].value) {
            smallest = right;
        }
        
        if (smallest == index) break;
        
        HeapItem temp = heap->items[index];
        heap->items[index] = heap->items[smallest];
        heap->items[smallest] = temp;
        index = smallest;
    }
}

void heapPush(MinHeap* heap, HeapItem item) {
    heap->items[heap->size] = item;
    heapifyUp(heap, heap->size);
    heap->size++;
}

HeapItem heapPop(MinHeap* heap) {
    HeapItem root = heap->items[0];
    heap->size--;
    heap->items[0] = heap->items[heap->size];
    heapifyDown(heap, 0);
    return root;
}

int* smallestRange(int** lists, int* listSizes, int k) {
    MinHeap* heap = createHeap(k);
    int maxVal = INT_MIN;
    
    // Initialize heap with first element from each list
    for (int i = 0; i < k; i++) {
        if (listSizes[i] > 0) {
            HeapItem item = {lists[i][0], i, 0};
            heapPush(heap, item);
            if (lists[i][0] > maxVal) {
                maxVal = lists[i][0];
            }
        }
    }
    
    int* bestRange = malloc(2 * sizeof(int));
    bestRange[0] = INT_MIN;
    bestRange[1] = INT_MAX;
    int bestSize = INT_MAX;
    
    while (heap->size > 0) {
        HeapItem current = heapPop(heap);
        int minVal = current.value;
        int listIdx = current.listIdx;
        int elemIdx = current.elemIdx;
        
        // Update best range if current is better
        int currentSize = maxVal - minVal;
        if (currentSize < bestSize || 
            (currentSize == bestSize && minVal < bestRange[0])) {
            bestSize = currentSize;
            bestRange[0] = minVal;
            bestRange[1] = maxVal;
        }
        
        // Try to add next element from the same list
        if (elemIdx + 1 < listSizes[listIdx]) {
            int nextVal = lists[listIdx][elemIdx + 1];
            HeapItem item = {nextVal, listIdx, elemIdx + 1};
            heapPush(heap, item);
            if (nextVal > maxVal) {
                maxVal = nextVal;
            }
        } else {
            // One list is exhausted
            break;
        }
    }
    
    free(heap->items);
    free(heap);
    return bestRange;
}

int main() {
    // Example usage
    int list1[] = {4, 10, 15, 24, 26};
    int list2[] = {0, 9, 12, 20};
    int list3[] = {5, 18, 22, 30};
    
    int* lists[] = {list1, list2, list3};
    int listSizes[] = {5, 4, 4};
    int k = 3;
    
    int* result = smallestRange(lists, listSizes, k);
    printf("[%d, %d]\n", result[0], result[1]);
    
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n * log k)

We process each element once (O(n total elements)) and each heap operation takes O(log k) where k is number of lists

⚡ Linearithmic

Space Complexity

O(k)

Heap contains at most k elements (one from each list)

✓ Linear Space

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

Constraints

Visualization

Related Problems

Common Approaches

Min-Heap + Sliding Window (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler