Minimum Operations to Make Array Equal II

Minimum Operations to Make Array Equal II - Problem

Transform One Array into Another

You're given two integer arrays nums1 and nums2 of equal length n, and an integer k. Your goal is to make nums1 exactly equal to nums2 using the minimum number of special operations.

Each operation allows you to:
• Choose any two indices i and j
• Add k to nums1[i]
• Subtract k from nums1[j]

This is like redistributing value between array elements in chunks of size k. The arrays are considered equal when nums1[i] == nums2[i] for all valid indices.

Challenge: Return the minimum number of operations needed, or -1 if it's impossible to make them equal.

Input & Output

example_1.py — Basic Operation

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

› Output: 2

💡 Note: We need 2 operations: First operation: add 3 to index 2, subtract 3 from index 0 → [1,3,4,4]. Second operation: add 3 to index 2, subtract 3 from index 3 → [1,3,7,1]. The differences are [-3,0,+6,-3], and we need to transfer the +6 surplus, requiring 6/3 = 2 operations.

example_2.py — Already Equal

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

› Output: 0

💡 Note: The arrays are already equal, so no operations are needed.

example_3.py — Impossible Case

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

› Output: -1

💡 Note: Differences are [-1,+1,-1,+1]. Since -1 and +1 are not divisible by k=2, transformation is impossible.

Constraints

n == nums1.length == nums2.length
1 ≤ n ≤ 10⁵
0 ≤ nums1[i], nums2[i] ≤ 10⁹
0 ≤ k ≤ 10⁵

Visualization

Tap to expand

Understanding the Visualization

Calculate Needs

Determine how much each position needs to gain or lose

Check Feasibility

Verify all differences are multiples of k and sum to zero

Count Operations

Sum up all positive differences (surplus) and divide by k

Key Takeaway

🎯 Key Insight: We only need to count positive differences (surplus elements) since each operation transfers from surplus to deficit, and the total operations equal sum of surpluses divided by k.

Asked in

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

The optimal solution uses mathematical analysis to recognize that each operation transfers exactly k units between elements. We calculate the difference array and count how many positive transfers are needed, which equals the sum of positive differences divided by k. The key insight is that we only need to count surplus elements since each operation pairs a surplus with a deficit.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Try All Combinations)	O(k^n)	O(k^n)	Try all possible operations and track minimum steps needed
Mathematical Analysis (Optimal)	O(n)	O(1)	Calculate differences and count positive transfers needed

Brute Force (Try All Combinations) — Algorithm Steps

Calculate differences between nums1 and nums2
Use BFS/DFS to try all possible operations
For each state, try all pairs of indices (i,j)
Track visited states to avoid cycles
Return minimum operations when target is reached

Visualization

Tap to expand

Step-by-Step Walkthrough

Calculate Differences

Find difference between target and current arrays

BFS Exploration

Try all possible (i,j) pairs for each operation

Track States

Avoid revisiting same array configurations

Find Minimum

Return shortest path to target state

Code -

solution.c — C

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

int minOperations(int* nums1, int nums1Size, int* nums2, int nums2Size, int k) {
    // Check if arrays are already equal
    int equal = 1;
    for (int i = 0; i < nums1Size; i++) {
        if (nums1[i] != nums2[i]) {
            equal = 0;
            break;
        }
    }
    if (equal) return 0;
    
    if (k == 0) return -1;
    
    // Calculate differences
    int* diffs = malloc(nums1Size * sizeof(int));
    long long sum = 0;
    
    for (int i = 0; i < nums1Size; i++) {
        diffs[i] = nums2[i] - nums1[i];
        sum += diffs[i];
    }
    
    if (sum != 0) {
        free(diffs);
        return -1;
    }
    
    // Simplified implementation - check if all differences are divisible by k
    for (int i = 0; i < nums1Size; i++) {
        if (diffs[i] % k != 0) {
            free(diffs);
            return -1;
        }
    }
    
    // Count positive differences (operations needed)
    int operations = 0;
    for (int i = 0; i < nums1Size; i++) {
        if (diffs[i] > 0) {
            operations += diffs[i] / k;
        }
    }
    
    free(diffs);
    return operations;
}

int main() {
    int nums1[] = {4, 3, 1, 4};
    int nums2[] = {1, 3, 7, 1};
    int k = 3;
    
    printf("%d\n", minOperations(nums1, 4, nums2, 4, k));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(k^n)

Each position can have many possible values, leading to exponential state space

✓ Linear Growth

Space Complexity

O(k^n)

Need to store all possible states in BFS queue or recursion stack

⚡ Linearithmic Space

31.5K Views

Medium Frequency

~18 min Avg. Time

1.3K 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 Combinations) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler