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

You have k lists of sorted integers in non-decreasing order. Find the smallest range that includes at least one number from each of the k lists.

We define the range [a, b] is smaller than range [c, d] if b - a < d - c or a < c if b - a == d - c.

Return the smallest range as an array [start, end].

Input & Output

Example 1 — Basic Case

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

› Output: [20,24]

💡 Note: The range [20,24] covers list 1 (24), list 2 (20), and list 3 (22). This gives the minimum range of 4.

Example 2 — Minimum Size

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

› Output: [1,1]

💡 Note: All lists contain 1, so the optimal range is [1,1] with range 0.

Example 3 — Different Ranges

$ Input: nums = [[10,20],[15,25],[5,30]]

› Output: [15,20]

💡 Note: Range [15,20] covers 20 from list 1, 15 from list 2, and no direct element from list 3, but we need at least one from each. Actually [15,20] covers list 2 (15) and list 1 (20), but we need list 3. The correct answer would be [15,25] covering 20 from list 1, 15 from list 2, and 25 from list 3.

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

Asked in

G Google 15 a Amazon 12 M Microsoft 8 f Facebook 6

The key insight is to maintain a sliding window that contains exactly one element from each list. The priority queue approach is optimal, using a min heap to track the smallest elements while maintaining the maximum. This achieves O(n log k) time complexity and O(k) space complexity.

Common Approaches

✓ Brute Force - All Combinations

⏱️ Time: O(n^k) Space: O(k)

Generate all possible combinations of elements (one from each list) and find the combination that gives the smallest range between minimum and maximum values.

Merge and Sliding Window

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

Create a merged sorted array with source list information. Use sliding window to find the smallest range that contains at least one element from each list.

Priority Queue (Min Heap) Approach

⏱️ Time: O(n log k) Space: O(k)

Maintain a min heap with one element from each list. Track the maximum element. Advance the minimum element to find the smallest possible range.

Brute Force - All Combinations — Algorithm Steps

Generate all combinations of k elements (one from each list)
For each combination, find min and max values
Track the combination with smallest range (max - min)

Visualization

Tap to expand

Step-by-Step Walkthrough

Input Lists

Three sorted lists with elements

Generate Combinations

Create all possible combinations (one from each list)

Find Minimum Range

Calculate range for each combination and find minimum

Code -

solution.c — C

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

static int combinations[1000000][10];
static int combCount = 0;

void generateCombinations(int** nums, int* numsSizes, int numsSize, int* current, int index) {
    if (index == numsSize) {
        for (int i = 0; i < numsSize; i++) {
            combinations[combCount][i] = current[i];
        }
        combCount++;
        return;
    }
    
    for (int i = 0; i < numsSizes[index]; i++) {
        current[index] = nums[index][i];
        generateCombinations(nums, numsSizes, numsSize, current, index + 1);
    }
}

int* solution(int** nums, int* numsSizes, int numsSize, int* returnSize) {
    *returnSize = 2;
    int* result = (int*)malloc(2 * sizeof(int));
    
    if (numsSize == 0) {
        *returnSize = 0;
        return result;
    }
    
    combCount = 0;
    int current[10];
    
    generateCombinations(nums, numsSizes, numsSize, current, 0);
    
    int minRange = INT_MAX;
    int bestMin = INT_MAX;
    int bestMax = INT_MIN;
    int hasResult = 0;
    
    for (int i = 0; i < combCount; i++) {
        int minVal = combinations[i][0];
        int maxVal = combinations[i][0];
        
        for (int j = 0; j < numsSize; j++) {
            if (combinations[i][j] < minVal) minVal = combinations[i][j];
            if (combinations[i][j] > maxVal) maxVal = combinations[i][j];
        }
        
        int currentRange = maxVal - minVal;
        
        if (!hasResult || currentRange < minRange || 
            (currentRange == minRange && minVal < bestMin)) {
            minRange = currentRange;
            bestMin = minVal;
            bestMax = maxVal;
            hasResult = 1;
        }
    }
    
    result[0] = bestMin;
    result[1] = bestMax;
    return result;
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    // Remove newline if present
    line[strcspn(line, "\n")] = 0;
    
    // Count the number of inner arrays
    int numsSize = 0;
    int inArray = 0;
    for (int i = 0; line[i]; i++) {
        if (line[i] == '[' && inArray) {
            numsSize++;
        }
        if (line[i] == '[') inArray = 1;
    }
    
    int** nums = (int**)malloc(numsSize * sizeof(int*));
    int* numsSizes = (int*)malloc(numsSize * sizeof(int));
    
    // Parse each inner array
    char* ptr = line;
    int listIndex = 0;
    
    while (*ptr && listIndex < numsSize) {
        // Find the next '['
        while (*ptr && *ptr != '[') ptr++;
        if (!*ptr) break;
        ptr++; // skip '['
        
        // Skip if this is the outer '['
        if (listIndex == 0 && ptr - line == 2) {
            while (*ptr && *ptr != '[') ptr++;
            if (!*ptr) break;
            ptr++; // skip inner '['
        }
        
        nums[listIndex] = (int*)malloc(100 * sizeof(int));
        numsSizes[listIndex] = 0;
        
        // Parse numbers until ']'
        while (*ptr && *ptr != ']') {
            if ((*ptr >= '0' && *ptr <= '9') || *ptr == '-') {
                char* endPtr;
                int num = strtol(ptr, &endPtr, 10);
                nums[listIndex][numsSizes[listIndex]++] = num;
                ptr = endPtr;
            } else {
                ptr++;
            }
        }
        
        listIndex++;
        if (*ptr == ']') ptr++; // skip ']'
    }
    
    int returnSize;
    int* result = solution(nums, numsSizes, numsSize, &returnSize);
    
    printf("[%d,%d]\n", result[0], result[1]);
    
    // Cleanup
    for (int i = 0; i < numsSize; i++) {
        free(nums[i]);
    }
    free(nums);
    free(numsSizes);
    free(result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n^k)

Generate all combinations where n is average list length and k is number of lists

✓ Linear Growth

Space Complexity

O(k)

Store current combination of k elements

✓ Linear Space

89.2K Views

Medium Frequency

~35 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 - All Combinations — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler