Program to find minimum number of increments on subarrays to form a target array in Python

Suppose we have an array called target with positive values. Now consider an array initial of same size with all zeros. We have to find the minimum number of operations required to generate a target array from the initial if we do this operation: Select any subarray from initial and increment each value by one.

So, if the input is like target = [2,3,4,3,2], then the output will be 4.

How It Works

The key insight is that we only need to increment when moving to a higher value. When the array decreases, we don't need additional operations since previous increments already cover the lower values.

Initially array was [0,0,0,0,0]:

• First pass: select subarray from index 0 to 4 and increase by 1 ? [1,1,1,1,1]

• Second pass: select from index 0 to 4 ? [2,2,2,2,2]

• Third pass: select elements from index 1 to 3 ? [2,3,3,3,2]

• Fourth pass: select index 2 ? [2,3,4,3,2]

Algorithm

To solve this, we follow these steps ?

• Initialize prev_num = 0 and steps = 0

• For each value in target:

  • If current value > previous value, add the difference to steps

  • Update previous value to current value

• Return total steps

Example

Let us see the following implementation to get better understanding ?

def solve(target):
    prev_num = 0
    steps = 0
    for val in target:
        steps += val - prev_num if val > prev_num else 0
        prev_num = val
    return steps

target = [2, 3, 4, 3, 2]
print(solve(target))

The output of the above code is ?

4

Step-by-Step Trace

Let's trace through the example [2,3,4,3,2] ?

def solve_with_trace(target):
    prev_num = 0
    steps = 0
    print(f"Target: {target}")
    
    for i, val in enumerate(target):
        increment = val - prev_num if val > prev_num else 0
        steps += increment
        print(f"Index {i}: val={val}, prev={prev_num}, increment={increment}, total_steps={steps}")
        prev_num = val
    
    return steps

target = [2, 3, 4, 3, 2]
result = solve_with_trace(target)
print(f"\nFinal result: {result}")

The output shows the step-by-step process ?

Target: [2, 3, 4, 3, 2]
Index 0: val=2, prev=0, increment=2, total_steps=2
Index 1: val=3, prev=2, increment=1, total_steps=3
Index 2: val=4, prev=3, increment=1, total_steps=4
Index 3: val=3, prev=4, increment=0, total_steps=4
Index 4: val=2, prev=3, increment=0, total_steps=4

Final result: 4

Conclusion

The algorithm works by counting only the upward transitions in the target array. When values decrease, no additional operations are needed since previous increments already cover those positions. This greedy approach gives the minimum number of operations required.