Kth Smallest Product of Two Sorted Arrays

Kth Smallest Product of Two Sorted Arrays - Problem

Imagine you're given two sorted arrays of integers, nums1 and nums2, and you need to find a very specific value: the kth smallest product that can be formed by multiplying any element from the first array with any element from the second array.

More formally, given two sorted 0-indexed integer arrays nums1 and nums2, and an integer k, return the kth (1-based) smallest product of nums1[i] * nums2[j] where 0 <= i < nums1.length and 0 <= j < nums2.length.

Example: If nums1 = [2, 5] and nums2 = [3, 4], the possible products are: [6, 8, 15, 20]. The 3rd smallest product would be 15.

Note: This problem becomes particularly challenging when dealing with negative numbers, as they can flip the ordering of products!

Input & Output

example_1.py — Basic Case

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

› Output: 8

💡 Note: All possible products: [2×3=6, 2×4=8, 5×3=15, 5×4=20]. Sorted: [6, 8, 15, 20]. The 2nd smallest is 8.

example_2.py — With Negatives

$ Input: nums1 = [-4, -2, 0, 3], nums2 = [2, 4], k = 6

› Output: 0

💡 Note: Products: [-16, -8, -8, -4, 0, 0, 6, 12]. Sorted: [-16, -8, -8, -4, 0, 0, 6, 12]. The 6th smallest is 0.

example_3.py — All Negative Products

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

› Output: -4

💡 Note: Products: [-2, -4, -1, -2]. Sorted: [-4, -2, -2, -1]. The 1st smallest (minimum) is -4.

Visualization

Tap to expand

Understanding the Visualization

Establish Boundaries

Find the minimum and maximum possible products from corner values

Make Smart Guess

Binary search picks the middle value as our candidate answer

Count Efficiently

Use sorted array properties to quickly count products ≤ our guess

Narrow Down

Based on count vs k, eliminate half of the search space

Repeat Until Found

Continue until we find the exact kth smallest product

Key Takeaway

🎯 Key Insight: Binary search on answer space + efficient counting beats generating all products, reducing complexity from O(nm log(nm)) to O((n+m) log(range))

Time & Space Complexity

Time Complexity

⏱️

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

O(n*m) to generate all products plus O(n*m*log(n*m)) to sort them

⚡ Linearithmic

Space Complexity

O(n*m)

Need to store all n*m products in memory

⚡ Linearithmic Space

Constraints

1 ≤ nums1.length, nums2.length ≤ 5 × 10⁴
-10⁵ ≤ nums1[i], nums2[j] ≤ 10⁵
1 ≤ k ≤ nums1.length × nums2.length
Both arrays are sorted in non-decreasing order

Asked in

G Google 45 f Meta 35 a Amazon 28 ⊞ Microsoft 22

The optimal solution uses binary search on the answer space rather than generating all products. We binary search on possible product values and for each candidate, efficiently count how many products are ≤ that value using the sorted property of input arrays. Key insight: counting products ≤ target can be done in O(n+m) time, making the overall complexity O((n+m) log(range)).

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Generate All Products)	O(nmlog(n*m))	O(n*m)	Generate all possible products, sort them, and return the kth element
Binary Search on Answer (Optimal)	O((n+m) * log(max_product - min_product))	O(1)	Binary search on the answer space and count products ≤ mid value

Brute Force (Generate All Products) — Algorithm Steps

Create an empty list to store all products
Use nested loops to calculate nums1[i] * nums2[j] for all valid i, j
Add each product to the list
Sort the list of products
Return the element at index k-1 (since k is 1-indexed)

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Matrix

Create all possible products in a matrix-like fashion

Collect Products

Add all products to a single array

Sort Array

Sort the array to find kth smallest

Return Result

Return the element at index k-1

Code -

solution.c — C

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

int compare(const void *a, const void *b) {
    long long la = *(const long long*)a;
    long long lb = *(const long long*)b;
    if (la < lb) return -1;
    if (la > lb) return 1;
    return 0;
}

long long kthSmallestProduct(int* nums1, int nums1Size, int* nums2, int nums2Size, long long k) {
    long long* products = malloc(nums1Size * nums2Size * sizeof(long long));
    int idx = 0;
    
    // Generate all possible products
    for (int i = 0; i < nums1Size; i++) {
        for (int j = 0; j < nums2Size; j++) {
            products[idx++] = (long long) nums1[i] * nums2[j];
        }
    }
    
    // Sort products and return kth smallest
    qsort(products, idx, sizeof(long long), compare);
    long long result = products[k - 1];
    free(products);
    return result;
}

int main() {
    int nums1[] = {2, 5};
    int nums2[] = {3, 4};
    long long k = 3;
    printf("%lld\n", kthSmallestProduct(nums1, 2, nums2, 2, k));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

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

O(n*m) to generate all products plus O(n*m*log(n*m)) to sort them

⚡ Linearithmic

Space Complexity

O(n*m)

Need to store all n*m products in memory

⚡ Linearithmic Space

Constraints

1 ≤ nums1.length, nums2.length ≤ 5 × 10⁴
-10⁵ ≤ nums1[i], nums2[j] ≤ 10⁵
1 ≤ k ≤ nums1.length × nums2.length
Both arrays are sorted in non-decreasing order

28.8K Views

Medium-High Frequency

~35 min Avg. Time

1.2K 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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Brute Force (Generate All Products) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler