Find K Pairs with Smallest Sums - Practice Coding Problems

Find K Pairs with Smallest Sums - Problem

Find K Pairs with Smallest Sums

Imagine you're a data analyst tasked with finding the most cost-effective combinations from two sorted price lists! 💰

You are given two integer arrays nums1 and nums2, both sorted in non-decreasing order, and an integer k. Your mission is to find the k pairs with the smallest sums.

A pair (u, v) consists of one element u from the first array and one element v from the second array. The sum of a pair is simply u + v.

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

Example: If nums1 = [1,7,11] and nums2 = [2,4,6], the pair (1,2) has sum 3, which would be the smallest possible sum.

Input & Output

example_1.py — 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) with sum 3, (1,4) with sum 5, and (1,6) with sum 7. Since all pairs with nums1[0]=1 have the smallest possible sums, we return these first.

example_2.py — Larger K

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

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

💡 Note: The first 2 pairs with smallest sums are: (1,1) with sum 2, and another (1,1) with sum 2. Both use the first element from nums1 and the first element from nums2.

example_3.py — K Exceeds Total Pairs

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

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

💡 Note: Only 2 pairs are possible: (1,3) with sum 4 and (2,3) with sum 5. Since k=3 exceeds the total number of pairs, 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

Understanding the Visualization

Start with Cheapest Base

Begin with the cheapest appetizer paired with all main courses - these are your initial candidates

Pick Best Available

Always choose the combination with the lowest current total cost

Smart Expansion

When you pick a combination, add the next pricier appetizer with the same main course as a new candidate

Repeat Until Complete

Continue until you've found k combinations - no need to check all possibilities!

Key Takeaway

🎯 Key Insight: By using a min-heap and leveraging the sorted nature of both arrays, we only explore the most promising combinations, achieving O(k*log(min(k,m))) complexity instead of O(m*n*log(m*n)) for the brute force approach!

Asked in

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

The optimal solution uses a min-heap approach with time complexity O(k*log(min(k,m))). Instead of generating all possible pairs, we leverage the sorted property of both arrays and use a priority queue to efficiently track and extract the k smallest sums. The key insight is to start with pairs involving the smallest element from nums1, then systematically explore larger combinations only as needed.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Generate All Pairs)	O(mnlog(m*n))	O(m*n)	Generate all possible pairs, sort by sum, return first k pairs
Min-Heap Approach (Optimal)	O(k*log(min(k, m)))	O(min(k, m))	Use min-heap to efficiently track and extract k smallest pairs without generating all combinations

Brute Force (Generate All Pairs) — Algorithm Steps

Generate all possible pairs (i, j) where i ∈ nums1 and j ∈ nums2
Calculate sum for each pair and store as (sum, i, j)
Sort all pairs by their sum values
Return the first k pairs from sorted list

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate All Pairs

Create every possible combination from both arrays

Calculate Sums

Compute sum for each pair

Sort by Sum

Sort all pairs by their sum values

Return First K

Take the first k pairs from sorted list

Code -

solution.c — C

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

typedef struct {
    int sum, val1, val2;
} Pair;

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

int** kSmallestPairs(int* nums1, int nums1Size, int* nums2, int nums2Size, int k, int* returnSize, int** returnColumnSizes) {
    Pair* pairs = malloc(nums1Size * nums2Size * sizeof(Pair));
    int pairCount = 0;
    
    // Generate all possible pairs
    for (int i = 0; i < nums1Size; i++) {
        for (int j = 0; j < nums2Size; j++) {
            pairs[pairCount++] = (Pair){nums1[i] + nums2[j], nums1[i], nums2[j]};
        }
    }
    
    // Sort by sum
    qsort(pairs, pairCount, sizeof(Pair), compare);
    
    // Prepare result
    *returnSize = (k < pairCount) ? k : pairCount;
    *returnColumnSizes = malloc(*returnSize * sizeof(int));
    int** result = malloc(*returnSize * sizeof(int*));
    
    for (int i = 0; i < *returnSize; i++) {
        (*returnColumnSizes)[i] = 2;
        result[i] = malloc(2 * sizeof(int));
        result[i][0] = pairs[i].val1;
        result[i][1] = pairs[i].val2;
    }
    
    free(pairs);
    return result;
}

Time & Space Complexity

Time Complexity

⏱️

O(m*n*log(m*n))

O(m*n) to generate all pairs plus O(m*n*log(m*n)) for sorting

⚡ Linearithmic

Space Complexity

O(m*n)

Space to store all m*n pairs before sorting

⚡ Linearithmic Space

142.4K Views

High Frequency

~18 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

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force (Generate All Pairs) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler