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

You are given an integer array target. You have an integer array initial of the same size as target with all elements initially zeros.

In one operation you can choose any subarray from initial and increment each value by one.

Return the minimum number of operations to form a target array from initial.

The test cases are generated so that the answer fits in a 32-bit integer.

Input & Output

Example 1 — Basic Mountain Shape

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

› Output: 3

💡 Note: We need 3 operations: first element (1), increase to 2 (+1), increase to 3 (+1). Decreases are free since we can extend previous operations.

Example 2 — Multiple Peaks

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

› Output: 4

💡 Note: Start with 3 operations for first element. Then 1≤3 (free), 1=1 (free), 2>1 so add 1 more. Total: 3+0+0+1=4.

Example 3 — Increasing Sequence

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

› Output: 3

💡 Note: First element needs 1 operation. Second is same (free). Then +1 for height 2, +1 for height 3. Total: 1+0+1+1=3.

Constraints

1 ≤ target.length ≤ 10⁵
1 ≤ target[i] ≤ 10⁵

Visualization

Tap to expand

Asked in

a Amazon 15 G Google 12

The key insight is to only count increases in the array - decreases are free. The greedy approach counts the first element plus all upward jumps. Time: O(n), Space: O(1).

Common Approaches

✓ Brute Force Simulation

⏱️ Time: O(n × max(target)) Space: O(n)

Repeatedly find the minimum non-zero value, subtract it from all elements, and count operations. This simulates the reverse process of building the target array.

Greedy Difference Counting

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

The key insight is that we only need to pay for increases. When building left to right, each increase in height requires additional operations, while decreases are free.

Monotonic Stack Approach

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

Maintain a stack of elements in non-decreasing order. When we encounter a smaller element, pop from stack and calculate contributions. This approach directly models the subarray operations.

Brute Force Simulation — Algorithm Steps

Find minimum non-zero value in current array
Subtract this value from all elements
Add this value to operation count
Repeat until all elements are zero

Visualization

Tap to expand

Step-by-Step Walkthrough

Find Minimum

Find smallest non-zero value

Subtract

Subtract from all positive elements

Count

Add to operation count

Code -

solution.c — C

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

int hasPositive(int* arr, int n) {
    for (int i = 0; i < n; i++) {
        if (arr[i] > 0) return 1;
    }
    return 0;
}

int solution(int* target, int n) {
    int* arr = (int*)malloc(n * sizeof(int));
    for (int i = 0; i < n; i++) {
        arr[i] = target[i];
    }
    
    int operations = 0;
    
    while (hasPositive(arr, n)) {
        int i = 0;
        while (i < n) {
            if (arr[i] > 0) {
                // Found start of a segment, find minimum in this segment
                int start = i;
                int min_val = INT_MAX;
                while (i < n && arr[i] > 0) {
                    if (arr[i] < min_val) {
                        min_val = arr[i];
                    }
                    i++;
                }
                
                // Subtract min_val from this segment only
                operations += min_val;
                for (int j = start; j < i; j++) {
                    arr[j] -= min_val;
                }
            } else {
                i++;
            }
        }
    }
    
    free(arr);
    return operations;
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    int target[1000];
    int n = 0;
    
    char* ptr = strchr(line, '[') + 1;
    char* token = strtok(ptr, ",]");
    while (token != NULL) {
        target[n++] = atoi(token);
        token = strtok(NULL, ",]");
    }
    
    int result = solution(target, n);
    printf("%d\n", result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n × max(target))

For each unique value in target, we scan the entire array

✓ Linear Growth

Space Complexity

O(n)

Need to store a copy of the target array for modification

✓ Linear Space

89.0K Views

Medium Frequency

~15 min Avg. Time

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

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

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force Simulation — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler