Find K Pairs with Smallest Sums

Find K Pairs with Smallest Sums - Problem

You are given two integer arrays nums1 and nums2 sorted in non-decreasing order and an integer k.

Define a pair (u, v) which consists of one element from the first array and one element from the second array.

Return the k pairs (u₁, v₁), (u₂, v₂), ..., (uₖ, vₖ) with the smallest sums.

Input & Output

Example 1 — Basic Case

$ Input: nums1 = [1,7,11], nums2 = [2,4,6], k = 3

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

💡 Note: The first 3 pairs with smallest sums are: (1,2)→3, (1,4)→5, (1,6)→7. All pairs from nums1[0] have the smallest possible sums.

Example 2 — Mixed Selection

$ Input: nums1 = [1,1,2], nums2 = [1,2,3], k = 2

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

💡 Note: The pairs with smallest sums are: (1,1)→2 and (1,1)→2. Both nums1[0] and nums1[1] paired with nums2[0] give the minimum sum.

Example 3 — Single Elements

$ Input: nums1 = [1,2], nums2 = [3], k = 3

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

💡 Note: Only 2 pairs are possible: (1,3)→4 and (2,3)→5. Since k=3 but only 2 pairs exist, we return all available pairs.

Constraints

1 ≤ nums1.length, nums2.length ≤ 10⁵
-10⁹ ≤ nums1[i], nums2[i] ≤ 10⁹
nums1 and nums2 both are sorted in non-decreasing order
1 ≤ k ≤ 10⁴

Visualization

Tap to expand

Asked in

G Google 45 a Amazon 32 M Microsoft 28

The key insight is to use a min-heap to systematically explore pairs in order of their sum values, starting from the smallest possible pair. Best approach uses heap optimization with Time: O(k×log(min(k,m))), Space: O(min(k,m)) which is much more efficient than generating all possible pairs.

Common Approaches

✓ Sliding Window

⏱️ Time: N/A Space: N/A

Optimized

⏱️ Time: N/A Space: N/A

Brute Force - Generate All Pairs

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

Create every possible pair between nums1 and nums2, calculate their sums, sort all pairs by sum, then return the first k pairs. This is straightforward but inefficient for large arrays.

Min-Heap Optimization

⏱️ Time: O(k×log(min(k,m))) Space: O(min(k,m))

Start with the smallest possible pair and use a min-heap to systematically explore the next smallest pairs. This avoids generating all combinations and is much more efficient when k is small compared to the total number of possible pairs.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

typedef struct {
    int first;
    int second;
    int sum;
} Pair;

int compare(const void* a, const void* b) {
    Pair* pairA = (Pair*)a;
    Pair* pairB = (Pair*)b;
    return pairA->sum - pairB->sum;
}

void parseArray(const char* str, int* arr, int* size) {
    *size = 0;
    const char* p = str;
    
    // Find opening bracket
    while (*p && *p != '[') p++;
    if (*p != '[') return;
    p++;
    
    // Check for empty array
    while (*p == ' ') p++;
    if (*p == ']') return;
    
    // Parse numbers
    while (*p && *p != ']') {
        // Skip whitespace and commas
        while (*p == ' ' || *p == ',') p++;
        if (*p == ']' || *p == '\0') break;
        
        // Parse number (handle negative numbers)
        char* endptr;
        arr[(*size)++] = (int)strtol(p, &endptr, 10);
        p = endptr;
    }
}

int main() {
    char line1[10000], line2[10000], line3[100];
    
    if (!fgets(line1, sizeof(line1), stdin)) return 1;
    if (!fgets(line2, sizeof(line2), stdin)) return 1;
    if (!fgets(line3, sizeof(line3), stdin)) return 1;
    
    // Remove newlines
    line1[strcspn(line1, "\n")] = 0;
    line2[strcspn(line2, "\n")] = 0;
    line3[strcspn(line3, "\n")] = 0;
    
    int nums1[1000], nums2[1000];
    int size1, size2;
    int k = atoi(line3);
    
    parseArray(line1, nums1, &size1);
    parseArray(line2, nums2, &size2);
    
    // Generate all pairs
    static Pair pairs[1000000];
    int pairCount = 0;
    
    for (int i = 0; i < size1; i++) {
        for (int j = 0; j < size2; j++) {
            pairs[pairCount].first = nums1[i];
            pairs[pairCount].second = nums2[j];
            pairs[pairCount].sum = nums1[i] + nums2[j];
            pairCount++;
        }
    }
    
    // Sort pairs by sum
    qsort(pairs, pairCount, sizeof(Pair), compare);
    
    // Output first k pairs in JSON format
    printf("[");
    int outputCount = (k < pairCount) ? k : pairCount;
    for (int i = 0; i < outputCount; i++) {
        if (i > 0) printf(",");
        printf("[%d,%d]", pairs[i].first, pairs[i].second);
    }
    printf("]\n");
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

⚡ Linearithmic

Space Complexity

⚡ Linearithmic Space

142.5K Views

Medium Frequency

~25 min Avg. Time

2.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