Minimum Equal Sum of Two Arrays After Replacing Zeros

Minimum Equal Sum of Two Arrays After Replacing Zeros - Problem

Array Greedy Medium

Minimum Equal Sum of Two Arrays After Replacing Zeros

You are given two arrays nums1 and nums2 consisting of positive integers and zeros. Your task is to replace all zeros in both arrays with strictly positive integers (1, 2, 3, ...) such that the sum of elements in both arrays becomes equal.

The challenge is to find the minimum possible equal sum that can be achieved, or return -1 if it's impossible to make the sums equal.

Key Points:

Zeros must be replaced with positive integers (≥ 1)
Non-zero elements cannot be changed
Both arrays must have the same final sum
We want the minimum possible equal sum

Example: If nums1 = [3, 2, 0, 1, 0] and nums2 = [6, 5, 0], we can replace zeros optimally to make both sums equal to 13.

Input & Output

example_1.py — Basic Case

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

› Output: 12

💡 Note: Array 1: non-zero sum = 6, zeros = 2, min sum = 8. Array 2: non-zero sum = 11, zeros = 1, min sum = 12. Since max(8,12) = 12, we can make both equal 12: [3,2,1,1,5] and [6,5,1].

example_2.py — Impossible Case

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

› Output: -1

💡 Note: Array 1 has sum 3 with no zeros, Array 2 has sum 7 with no zeros. Since neither can be modified, they cannot be made equal.

example_3.py — Edge Case

$ Input: nums1 = [0, 0], nums2 = [1, 1]

› Output: 2

💡 Note: Array 1: min sum = 0 + 2 = 2. Array 2: sum = 2, no zeros. Both can equal 2: [1,1] and [1,1].

Constraints

1 ≤ nums1.length, nums2.length ≤ 10⁵
0 ≤ nums1[i], nums2[i] ≤ 1000
At least one element in each array is positive

Visualization

Tap to expand

Understanding the Visualization

Count Fixed Items

Sum up all items with known prices in both carts

Count Mystery Boxes

Count how many mystery boxes (zeros) each cart has

Calculate Minimum Values

Minimum cart value = fixed items + (mystery boxes × $1)

Find Target Balance

The target is the higher of the two minimum values

Check Feasibility

If a cart has no mystery boxes but lower value, impossible to balance

Key Takeaway

🎯 Key Insight: The minimum equal sum is determined by the cart that needs the higher minimum value. The other cart can always adjust its mystery boxes to match this target.

Asked in

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

The optimal solution uses a greedy approach with mathematical insight. Calculate the minimum possible sum for each array (non-zero elements + number of zeros), then return the maximum of these sums. If an array has no zeros but a smaller sum than the other's minimum, return -1. This achieves O(n) time complexity with constant space.

Common Approaches

Approach	Time	Space	Notes
✓ Greedy Approach (Optimal)	O(n + m)	O(1)	Calculate minimum possible sums and determine if equality is achievable
Brute Force (Try All Combinations)	O(k^z1 × k^z2)	O(z1 + z2)	Try all possible ways to replace zeros and check for equal sums

Greedy Approach (Optimal) — Algorithm Steps

Calculate the sum of non-zero elements in both arrays
Count the number of zeros in both arrays
Calculate minimum possible sum for each array (non-zero sum + zeros count)
If one array has no zeros but different sum than the other's minimum, return -1
Otherwise, the answer is the maximum of both minimum possible sums

Visualization

Tap to expand

Step-by-Step Walkthrough

Calculate Non-Zero Sums

Sum all non-zero elements in both arrays

Count Zeros

Count zeros in both arrays (these become 1s minimum)

Find Minimum Sums

MinSum = NonZeroSum + ZeroCount

Check Feasibility

If any array has no zeros but smaller sum, return -1

Return Maximum

Return max(minSum1, minSum2) as the answer

Code -

solution.c — C

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

long long minimumSum(int* nums1, int size1, int* nums2, int size2) {
    long long sum1 = 0, sum2 = 0;
    int zeros1 = 0, zeros2 = 0;
    
    // Process first array
    for (int i = 0; i < size1; i++) {
        if (nums1[i] == 0) {
            zeros1++;
        } else {
            sum1 += nums1[i];
        }
    }
    
    // Process second array
    for (int i = 0; i < size2; i++) {
        if (nums2[i] == 0) {
            zeros2++;
        } else {
            sum2 += nums2[i];
        }
    }
    
    // Calculate minimum sums
    long long minSum1 = sum1 + zeros1;
    long long minSum2 = sum2 + zeros2;
    
    // Check feasibility
    if (zeros1 == 0 && minSum1 < minSum2) return -1;
    if (zeros2 == 0 && minSum2 < minSum1) return -1;
    
    return (minSum1 > minSum2) ? minSum1 : minSum2;
}

int main() {
    // Input parsing would be implemented here
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n + m)

Single pass through both arrays to calculate sums and count zeros

✓ Linear Growth

Space Complexity

O(1)

Only using a few variables to store sums and counts

✓ Linear Space

26.8K Views

Medium Frequency

~15 min Avg. Time

892 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

Greedy Approach (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler