Minimum Operations to Make Array Equal to Target

Minimum Operations to Make Array Equal to Target - Problem

You are given two positive integer arrays nums and target, of the same length. In a single operation, you can select any subarray of nums and increment each element within that subarray by 1 or decrement each element within that subarray by 1.

Return the minimum number of operations required to make nums equal to the array target.

Input & Output

Example 1 — Basic Case

$ Input: nums = [3,5,1,2], target = [4,6,2,4]

› Output: 7

💡 Note: We need to transform [3,5,1,2] to [4,6,2,4]. Optimal operations: increment subarray [0,1] by 1, increment subarray [2,3] by 1, then increment subarray [3,3] by 2. Total: 2 + 2 + 2 + 1 = 7 operations.

Example 2 — All Same Target

$ Input: nums = [1,3,2], target = [2,1,4]

› Output: 5

💡 Note: Transform [1,3,2] to [2,1,4]: increment nums[0] by 1, decrement nums[1] by 2, increment nums[2] by 2. Operations: 1 + 2 + 2 = 5.

Example 3 — Already Equal

$ Input: nums = [1,2,3], target = [1,2,3]

› Output: 0

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

Constraints

1 ≤ nums.length == target.length ≤ 10⁵
1 ≤ nums[i], target[i] ≤ 10⁸

Visualization

Tap to expand

Asked in

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

The key insight is to process positive and negative differences separately using two passes. The optimal approach handles increments and decrements independently to minimize total operations. Best approach uses two-pass greedy algorithm. Time: O(n), Space: O(1)

Common Approaches

✓ Brute Force

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

For each position, calculate the difference between nums[i] and target[i], then count all required increment/decrement operations. This approach doesn't utilize the subarray operation efficiency.

Greedy with Difference Array

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

Create a difference array where diff[i] = target[i] - nums[i]. Process from left to right, tracking cumulative operations needed. When difference changes, we need additional operations.

Monotonic Stack (Optimal)

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

The key insight is that we can handle positive and negative differences separately. For positive differences (increments), we use a greedy approach. For negative differences (decrements), we track them with a stack to optimize subarray operations.

Brute Force — Algorithm Steps

Calculate difference for each position
Sum all absolute differences
Return total operations

Visualization

Tap to expand

Step-by-Step Walkthrough

Calculate Differences

Find diff between each nums[i] and target[i]

Sum Absolute Values

Add all |differences| together

Result

Total operations needed

Code -

solution.c — C

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

long long solution(int* nums, int numsSize, int* target, int targetSize) {
    if (numsSize == 0) {
        return 0;
    }
    
    long long operations = 0;
    long long prev_diff = 0;
    
    for (int i = 0; i < numsSize; i++) {
        long long curr_diff = (long long)target[i] - (long long)nums[i];
        
        if (curr_diff > prev_diff) {
            operations += curr_diff - prev_diff;
        }
        
        prev_diff = curr_diff;
    }
    
    return operations;
}

void parseArray(const char* str, int* arr, int* size) {
    *size = 0;
    const char* p = str;
    
    while (*p && *p != '[') p++;
    if (*p == '[') p++;
    
    while (*p && *p != ']') {
        while (*p == ' ' || *p == ',') p++;
        if (*p == ']' || *p == '\0') break;
        
        if (*p == '-' || (*p >= '0' && *p <= '9')) {
            arr[(*size)++] = (int)strtol(p, (char**)&p, 10);
        } else {
            p++;
        }
    }
}

int main() {
    char line1[10000], line2[10000];
    
    if (fgets(line1, sizeof(line1), stdin) == NULL) {
        return 1;
    }
    if (fgets(line2, sizeof(line2), stdin) == NULL) {
        return 1;
    }
    
    line1[strcspn(line1, "\n")] = 0;
    line2[strcspn(line2, "\n")] = 0;
    
    int nums[1000], target[1000];
    int numsSize = 0, targetSize = 0;
    
    parseArray(line1, nums, &numsSize);
    parseArray(line2, target, &targetSize);
    
    printf("%lld\n", solution(nums, numsSize, target, targetSize));
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through array to calculate differences

✓ Linear Growth

Space Complexity

O(1)

Only using variables for counting

✓ Linear Space

28.5K Views

Medium Frequency

~35 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

Brute Force — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler