Minimize Product Sum of Two Arrays - Practice Coding Problems

Minimize Product Sum of Two Arrays - Problem

Minimize Product Sum of Two Arrays

Imagine you're a data analyst trying to minimize the product sum between two datasets. The product sum of two equal-length arrays a and b is calculated as the sum of a[i] * b[i] for all valid indices.

For example, if a = [1,2,3,4] and b = [5,2,3,1], the product sum would be:
1×5 + 2×2 + 3×3 + 4×1 = 5 + 4 + 9 + 4 = 22

Here's the twist: you can rearrange the elements in the first array to achieve the minimum possible product sum. Your goal is to find the optimal arrangement that minimizes this sum.

Input: Two integer arrays nums1 and nums2 of equal length n
Output: The minimum product sum after optimally rearranging nums1

Input & Output

example_1.py — Basic Case

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

› Output: 25

💡 Note: We can rearrange nums1 to [1,2,4,5]. The product sum is 1×3 + 2×1 + 4×6 + 5×2 = 3 + 2 + 24 + 10 = 39. But optimally: sort nums1=[1,2,4,5] with nums2 sorted desc=[6,3,2,1] gives 1×6 + 2×3 + 4×2 + 5×1 = 6+6+8+5 = 25

example_2.py — Simple Pair

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

› Output: 11

💡 Note: Arrange nums1 as [2,5] to pair with nums2=[3,1]. Product sum = 2×3 + 5×1 = 6 + 5 = 11. This pairs the smaller value 2 with larger value 3, and larger value 5 with smaller value 1.

example_3.py — All Same Values

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

› Output: 18

💡 Note: When all elements are the same, any arrangement gives the same result: 3×2 + 3×2 + 3×2 = 6 + 6 + 6 = 18

Constraints

1 ≤ n ≤ 10⁵ where n is the length of both arrays
1 ≤ nums1[i], nums2[i] ≤ 100
Both arrays have the same length
All array elements are positive integers

Visualization

Tap to expand

Understanding the Visualization

Identify Resources

You have investments (nums1) you can rearrange and market prices (nums2) that are fixed

Apply Strategy

Pair your smallest investments with the highest market prices to minimize total cost

Calculate Result

Sum all the investment×price products to get the minimum total cost

Key Takeaway

🎯 Key Insight: The greedy strategy of pairing smallest elements from the rearrangeable array with largest elements from the fixed array minimizes the total product sum

Asked in

G Google 45 a Amazon 38 f Meta 32 ⊞ Microsoft 28

The optimal greedy approach sorts nums1 in ascending order and nums2 in descending order, then pairs corresponding elements. This strategy minimizes the product sum by pairing the smallest values from the rearrangeable array with the largest values from the fixed array. Time complexity: O(n log n), Space complexity: O(1).

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Try All Permutations)	O(n! × n)	O(n)	Generate all possible permutations of nums1 and find the minimum product sum
Greedy Approach (Sort + Pair Optimally)	O(n log n)	O(1)	Sort nums1 ascending and nums2 descending, then pair elements optimally

Brute Force (Try All Permutations) — Algorithm Steps

Generate all permutations of nums1
For each permutation, calculate product sum with nums2
Keep track of minimum sum encountered
Return the minimum sum

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Permutations

Create all possible arrangements of nums1

Calculate Product Sum

For each arrangement, compute sum of products

Track Minimum

Keep the smallest sum found so far

Code -

solution.c — C

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

int minSum = INT_MAX;

void swap(int* a, int* b) {
    int temp = *a;
    *a = *b;
    *b = temp;
}

void permute(int* nums1, int* nums2, int n, int start) {
    if (start == n) {
        int sum = 0;
        for (int i = 0; i < n; i++) {
            sum += nums1[i] * nums2[i];
        }
        if (sum < minSum) minSum = sum;
        return;
    }
    
    for (int i = start; i < n; i++) {
        swap(&nums1[start], &nums1[i]);
        permute(nums1, nums2, n, start + 1);
        swap(&nums1[start], &nums1[i]);
    }
}

int minProductSum(int* nums1, int* nums2, int n) {
    minSum = INT_MAX;
    permute(nums1, nums2, n, 0);
    return minSum;
}

int main() {
    // Parse input and call solution
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n! × n)

O(n!) permutations, each taking O(n) time to calculate product sum

⚠ Quadratic Growth

Space Complexity

O(n)

Space for storing current permutation and recursion stack

⚡ Linearithmic Space

42.3K Views

Medium Frequency

~15 min Avg. Time

1.5K 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 (Try All Permutations) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler