Report: Find K Pairs with Smallest Sums (LeetCode 373)

Problem Description

This problem asks us to find the k pairs with the smallest sums from two given sorted integer arrays, nums1 and nums2. A pair (u, v) consists of one element u from nums1 and one element v from nums2.

Solution Approach: Min-Priority Queue (Min-Heap)

The problem is a classic "Top K" problem, best solved efficiently using a Min-Priority Queue (Min-Heap).

Reasoning:

Since both input arrays nums1 and nums2 are sorted in non-decreasing order, the smallest possible sum will always come from (nums1[0], nums2[0]). From this starting point, we want to systematically explore subsequent pairs in an order that ensures we always pick the globally smallest available sum at each step. A min-heap naturally facilitates this by always providing the element with the lowest priority (in our case, the smallest sum).

Algorithm Steps:

1. Initialize a Min-Heap: Create a min-priority queue. Each element in the heap will be a tuple [sum, index1, index2], where sum is nums1[index1] + nums2[index2]. The heap will be ordered by sum.

2. Initial Population of Heap:

   • Add the first min(k, nums1.length) pairs formed by nums1[i] and nums2[0] to the min-heap.
   • We only need to consider nums2[0] for initial pairs because for any nums1[i], pairing it with nums2[0] will yield the smallest sum involving nums1[i] as the first element. Limiting to min(k, nums1.length) prevents unnecessary additions if nums1 is very large but k is small.

3. Extract K Smallest Pairs:

   • Initialize an empty list result to store the output pairs.
   • While the heap is not empty and result.length is less than k:
     • Extract the smallest element from the heap: [currentSum, i, j].
     • Add the actual pair [nums1[i], nums2[j]] to the result list.
     • Explore Next Candidate: If j + 1 is a valid index within nums2 (i.e., j + 1 < nums2.length), it means we can potentially form a new smaller sum by pairing nums1[i] with the next element in nums2. Push this new candidate [nums1[i] + nums2[j+1], i, j+1] onto the heap. This is crucial for correctly exploring the search space.

4. Return result: Once k pairs are collected or the heap becomes empty, result contains the k pairs with the smallest sums.

Complexity Analysis

• Time Complexity: O(k log k)

  • Initialization: Adding min(k, nums1.length) elements to the heap takes approximately O(min(k, nums1.length) * log(min(k, nums1.length))) time. In the worst case, this is O(k log k).
  • Extraction Loop: We extract k elements from the heap. Each pop operation takes O(log H) time, where H is the heap size. The maximum heap size is k. Each push operation (for the next candidate) also takes O(log H) time. Since we perform k pops and at most k pushes, the total time for this phase is O(k log k).
  • Combining these, the dominant factor is O(k log k).

• Space Complexity: O(k)

  • The min_heap stores at most k elements at any given time.
  • The result list stores k pairs.
  • Therefore, the space complexity is O(k).

Code (JavaScript)

class MinHeap {
 constructor() {
 this.heap = [];
 }
 size() {
 return this.heap.length;
 }
 push(element) {
 this.heap.push(element);
 this._bubbleUp(this.heap.length - 1);
 }
 pop() {
 if (this.heap.length === 0) {
 return null;
 }
 if (this.heap.length === 1) {
 return this.heap.pop();
 }
 const min = this.heap[0];
 this.heap[0] = this.heap.pop();
 this._bubbleDown(0);
 return min;
 }
 peek() {
 return this.heap.length > 0 ? this.heap[0] : null;
 }
 _bubbleUp(index) {
 while (index > 0) {
 const parentIndex = Math.floor((index - 1) / 2);
 if (this.heap[parentIndex][0] > this.heap[index][0]) {
 [this.heap[parentIndex], this.heap[index]] = [this.heap[index], this.heap[parentIndex]];
 index = parentIndex;
 } else {
 break;
 }
 }
 }
 _bubbleDown(index) {
 const lastIndex = this.heap.length - 1;
 while (true) {
 let leftChildIndex = 2 * index + 1;
 let rightChildIndex = 2 * index + 2;
 let smallestChildIndex = index;
 if (leftChildIndex <= lastIndex && this.heap[leftChildIndex][0] < this.heap[smallestChildIndex][0]) {
 smallestChildIndex = leftChildIndex;
 }
 if (rightChildIndex <= lastIndex && this.heap[rightChildIndex][0] < this.heap[smallestChildIndex][0]) {
 smallestChildIndex = rightChildIndex;
 }
 if (smallestChildIndex !== index) {
 [this.heap[index], this.heap[smallestChildIndex]] = [this.heap[smallestChildIndex], this.heap[index]];
 index = smallestChildIndex;
 } else {
 break;
 }
 }
 }
}
var kSmallestPairs = function(nums1, nums2, k) {
 if (!nums1.length || !nums2.length || k === 0) {
 return [];
 }
 const minHeap = new MinHeap();
 const result = [];
 for (let i = 0; i < Math.min(k, nums1.length); i++) {
 minHeap.push([nums1[i] + nums2[0], i, 0]);
 }
 while (minHeap.size() > 0 && result.length < k) {
 const [currentSum, i, j] = minHeap.pop();
 result.push([nums1[i], nums2[j]]);
 if (j + 1 < nums2.length) {
 minHeap.push([nums1[i] + nums2[j + 1], i, j + 1]);
 }
 }
 return result;
};