Minimum Number of Increments on Subarrays to Form a Target Array

Minimum Number of Increments on Subarrays to Form a Target Array - Problem

Imagine you're a game developer creating a terrain generator! You start with a completely flat landscape (all zeros) and need to build mountains and hills to match a target elevation map.

You are given an integer array target representing the desired elevation at each position. You start with an array initial of the same size, but all elements are initially 0 (flat ground).

In each operation, you can choose any contiguous subarray from your current landscape and raise the elevation by 1 across that entire range. Think of it as adding a layer of soil or rock across a continuous section.

Your goal is to find the minimum number of operations needed to transform your flat initial array into the target elevation map.

Example: If target = [1,2,3,2,1], you need to strategically choose subarrays to increment until you match this mountain-like shape with the fewest operations possible.

Input & Output

example_1.py — Basic Mountain

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

› Output: 3

💡 Note: We need 3 operations: First operation covers entire array [0→1,0→1,0→1,0→1,0→1]. Second operation covers middle section [1→2,1→2,1→2]. Third operation targets the peak [2→3]. This creates the mountain shape optimally.

example_2.py — Plateau

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

› Output: 4

💡 Note: Start with 3 operations for the first element. Then we have drops and rises: 3→1 (no extra ops), 1→1 (no extra ops), 1→2 (add 1 op). Total: 3 + 0 + 0 + 1 = 4 operations.

example_3.py — Single Element

$ Input: target = [1,1,1,1]

› Output: 1

💡 Note: Since all elements are the same height (1), we only need 1 operation to increment the entire array from [0,0,0,0] to [1,1,1,1].

Visualization

Tap to expand

Understanding the Visualization

Analyze Base Height

Start with target[0] operations to build the initial elevation

Process Increases

For each height increase, add new layer operations

Handle Decreases

Height decreases require no extra operations - layers naturally end

Sum Total

Total operations = base + all height increases

Key Takeaway

🎯 Key Insight: The greedy approach works because increment operations can be viewed as horizontal layers. When terrain height increases, we must start new layers. When it decreases, existing layers naturally terminate, requiring no additional operations.

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through the array

✓ Linear Growth

Space Complexity

O(1)

Only using constant extra space

✓ Linear Space

Constraints

1 ≤ target.length ≤ 10⁵
1 ≤ target[i] ≤ 10⁵
The answer is guaranteed to fit in a 32-bit integer

Asked in

G Google 28 a Amazon 22 f Meta 15 ⊞ Microsoft 12

The optimal solution uses a greedy approach that processes the array from left to right. The key insight is that we start with target[0] operations (base height), then for each position, if the height increases compared to the previous position, we need additional operations equal to the difference. This works because increment operations naturally end when the terrain height decreases, so we only pay for increases.

Common Approaches

Approach	Time	Space	Notes
✓ Greedy Approach (Optimal)	O(n)	O(1)	Process differences between adjacent elements greedily

Greedy Approach (Optimal) — Algorithm Steps

Initialize operations counter with target[0] (base height)
Iterate through array from index 1 to n-1
If target[i] > target[i-1]: add the difference to operations
If target[i] <= target[i-1]: no additional operations needed
Return total operations

Visualization

Tap to expand

Step-by-Step Walkthrough

Start with base

operations = target[0] = 3

Process differences

For each increase, add the difference

Final result

Sum all the increases: 3 + 0 + 0 + 0 = 3

Code -

solution.c — C

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

int minNumberOperations(int* target, int targetSize) {
    if (targetSize == 0) return 0;
    
    int operations = target[0];
    
    for (int i = 1; i < targetSize; i++) {
        if (target[i] > target[i-1]) {
            operations += target[i] - target[i-1];
        }
    }
    
    return operations;
}

int main() {
    char input[10000];
    fgets(input, sizeof(input), stdin);
    
    int target[1000];
    int size = 0;
    
    char* token = strtok(input + 1, ",]");
    while (token != NULL) {
        target[size++] = atoi(token);
        token = strtok(NULL, ",]");
    }
    
    printf("%d\n", minNumberOperations(target, size));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through the array

✓ Linear Growth

Space Complexity

O(1)

Only using constant extra space

✓ Linear Space

Constraints

1 ≤ target.length ≤ 10⁵
1 ≤ target[i] ≤ 10⁵
The answer is guaranteed to fit in a 32-bit integer

28.4K Views

Medium Frequency

~25 min Avg. Time

1.2K 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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Greedy Approach (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler