Minimum Operations to Make Array Equal II

Minimum Operations to Make Array Equal II - Problem

You are given two integer arrays nums1 and nums2 of equal length n and an integer k.

You can perform the following operation on nums1:

Choose two indexes i and j and increment nums1[i] by k and decrement nums1[j] by k. In other words, nums1[i] = nums1[i] + k and nums1[j] = nums1[j] - k.

nums1 is said to be equal to nums2 if for all indices i such that 0 <= i < n, nums1[i] == nums2[i].

Return the minimum number of operations required to make nums1 equal to nums2. If it is impossible to make them equal, return -1.

Input & Output

Example 1 — Basic Case

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

› Output: 2

💡 Note: diff = [3,-6,3]. Sum = 0, all divisible by 3. Need to transfer 3+3=6 units in steps of 3, so 2 operations: add 3 to index 0 and subtract from index 1, then add 3 to index 2 and subtract from index 1.

Example 2 — Possible Case

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

› Output: 1

💡 Note: diff = [4,-4,0]. Sum = 0, all divisible by 4. Need 1 operation: add 4 to index 0 and subtract 4 from index 1.

Example 3 — Valid Transformation

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

› Output: 0

💡 Note: Arrays are already equal, no operations needed.

Constraints

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

Visualization

Tap to expand

Asked in

G Google 25 M Microsoft 18 a Amazon 15 f Meta 12

The key insight is that each operation preserves the total sum of elements. If the sum of differences isn't zero or differences aren't divisible by k, transformation is impossible. The optimal approach counts positive differences divided by k. Time: O(n), Space: O(1)

Common Approaches

✓ Brute Force Simulation

⏱️ Time: O(n! × n²) Space: O(n²)

Generate all possible pairs of indices and try operations recursively. For each state, attempt every possible operation and track minimum operations needed.

Greedy Difference Matching

⏱️ Time: O(n) Space: O(1)

First check if transformation is possible by verifying sum and divisibility constraints. Then greedily match elements that need to give away with elements that need to receive.

Brute Force Simulation — Algorithm Steps

Calculate difference array
Try all possible i,j pairs for operations
Recursively solve remaining differences
Return minimum operations found

Visualization

Tap to expand

Step-by-Step Walkthrough

Calculate Differences

Find diff[i] = nums2[i] - nums1[i]

Try Operations

For each positive diff[i] and negative diff[j], try operation

Recurse

Continue until all differences become zero

Code -

solution.c — C

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

int backtrack(int* differences, int n, int k) {
    int allZero = 1;
    for (int i = 0; i < n; i++) {
        if (differences[i] != 0) {
            allZero = 0;
            break;
        }
    }
    if (allZero) return 0;
    
    int minOps = INT_MAX;
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
            if (i != j && differences[i] > 0 && differences[j] < 0) {
                int* newDiff = (int*)malloc(n * sizeof(int));
                memcpy(newDiff, differences, n * sizeof(int));
                newDiff[i] -= k;
                newDiff[j] += k;
                
                int result = backtrack(newDiff, n, k);
                free(newDiff);
                if (result != INT_MAX) {
                    if (1 + result < minOps) {
                        minOps = 1 + result;
                    }
                }
            }
        }
    }
    
    return minOps == INT_MAX ? -1 : minOps;
}

int solution(int* nums1, int* nums2, int n, int k) {
    int* diff = (int*)malloc(n * sizeof(int));
    long long sum = 0;
    
    for (int i = 0; i < n; i++) {
        diff[i] = nums2[i] - nums1[i];
        sum += diff[i];
    }
    
    if (sum != 0) {
        free(diff);
        return -1;
    }
    
    if (k != 0) {
        for (int i = 0; i < n; i++) {
            if (diff[i] % k != 0) {
                free(diff);
                return -1;
            }
        }
    }
    
    if (k == 0) {
        for (int i = 0; i < n; i++) {
            if (diff[i] != 0) {
                free(diff);
                return -1;
            }
        }
        free(diff);
        return 0;
    }
    
    int result = backtrack(diff, n, k);
    free(diff);
    return result;
}

int main() {
    char line[10000];
    
    // Read nums1
    fgets(line, sizeof(line), stdin);
    int nums1[1000], n1 = 0;
    char* token = strtok(line, "[,]\n");
    while (token != NULL) {
        if (strlen(token) > 0 && token[0] != ' ') {
            nums1[n1++] = atoi(token);
        }
        token = strtok(NULL, "[,]\n");
    }
    
    // Read nums2
    fgets(line, sizeof(line), stdin);
    int nums2[1000], n2 = 0;
    token = strtok(line, "[,]\n");
    while (token != NULL) {
        if (strlen(token) > 0 && token[0] != ' ') {
            nums2[n2++] = atoi(token);
        }
        token = strtok(NULL, "[,]\n");
    }
    
    int k;
    scanf("%d", &k);
    
    int result = solution(nums1, nums2, n1, k);
    printf("%d\n", result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n! × n²)

Each position can be modified in multiple ways, leading to factorial possibilities with quadratic operations

⚠ Quadratic Growth

Space Complexity

O(n²)

Recursion stack depth and state storage for attempted configurations

⚠ Quadratic Space

23.4K Views

Medium Frequency

~15 min Avg. Time

856 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 Simulation — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler