Minimum Operations to Convert All Elements to Zero

Minimum Operations to Convert All Elements to Zero - Problem

You are given an array nums of size n, consisting of non-negative integers. Your goal is to transform all elements in the array to 0 using the minimum number of operations possible.

In each operation, you can:

Select any subarray [i, j] where 0 ≤ i ≤ j < n
Find the minimum value in that subarray
Set all occurrences of that minimum value to 0 within the selected subarray

Example: If you have [3, 1, 2, 1] and select subarray [0, 3], the minimum is 1, so all 1s become 0, resulting in [3, 0, 2, 0].

Return the minimum number of operations required to make all elements equal to 0.

Input & Output

example_1.py — Simple Case

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

› Output: 2

💡 Note: Operation 1: Select entire array [0,3], minimum is 1, set all 1s to 0 → [2,0,3,0]. Operation 2: Select [0,2], minimum is 2, set to 0 → [0,0,3,0]. Operation 3: Select [2,2], minimum is 3, set to 0 → [0,0,0,0]. Total: 3 operations. But optimal is 2: First select [1,1] and [3,3] to eliminate 1s, then select [0,2] to eliminate remaining elements.

example_2.py — Monotonic Increasing

$ Input: [1, 2, 3, 4]

› Output: 4

💡 Note: Each element requires its own operation since they're in increasing order. Operation 1: [0,3] min=1 → [0,2,3,4]. Operation 2: [1,3] min=2 → [0,0,3,4]. Operation 3: [2,3] min=3 → [0,0,0,4]. Operation 4: [3,3] min=4 → [0,0,0,0].

example_3.py — All Same Elements

$ Input: [5, 5, 5, 5]

› Output: 1

💡 Note: All elements are the same, so in one operation we can select the entire array [0,3], find minimum 5, and set all occurrences to 0 → [0,0,0,0].

Visualization

Tap to expand

Understanding the Visualization

Identify Mountain Range

Array [3,1,2,1] represents mountains of heights 3,1,2,1

Find Nested Structures

Mountain 1 is surrounded by taller mountains, so it can be eliminated efficiently

Apply Stack Logic

Use monotonic stack to identify which mountains need separate demolition operations

Count Operations

Each element remaining in stack represents one demolition operation needed

Key Takeaway

🎯 Key Insight: The monotonic stack approach recognizes that elements surrounded by larger values can be eliminated together, minimizing the total number of operations needed.

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through the array, each element pushed/popped at most once

✓ Linear Growth

Space Complexity

O(n)

Stack can contain up to n elements in worst case

⚡ Linearithmic Space

Constraints

1 ≤ nums.length ≤ 10⁵
0 ≤ nums[i] ≤ 10⁹
At least one element in the array is positive
All elements are non-negative integers

Asked in

G Google 42 a Amazon 38 f Meta 35 ⊞ Microsoft 28

The optimal solution uses a monotonic stack to identify nested structures in O(n) time. Elements that are 'surrounded' by larger elements can be eliminated together, and the stack maintains the minimum number of operation 'layers' needed. This approach is much more efficient than the brute force simulation which would be exponential in complexity.

Common Approaches

Approach	Time	Space	Notes
✓ Monotonic Stack (Optimal)	O(n)	O(n)	Use stack to identify nested structures and minimize operations
Simulation with All Subarrays	O(2^n)	O(n)	Try all possible subarray selections and simulate the process

Monotonic Stack (Optimal) — Algorithm Steps

Use a monotonic stack to process elements from left to right
For each element, while stack top is greater, pop and count operations
Add current element to stack if it's not already there (or if stack is empty)
The final stack size represents the minimum operations needed

Visualization

Tap to expand

Step-by-Step Walkthrough

Process [3,1,2,1]

Start with empty stack, process each element

Add 3

Stack: [3]

Add 1

1 < 3, so pop 3. Stack: [1]

Add 2

2 > 1, stack: [1,2]

Process final 1

1 < 2, pop 2. 1 already in stack, don't add. Final: [1]

Code -

solution.c — C

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

int minimumOperations(int* nums, int n) {
    int* stack = malloc(n * sizeof(int));
    int stackSize = 0;
    
    for (int i = 0; i < n; i++) {
        int num = nums[i];
        
        // While stack top is greater than current, we can eliminate it
        while (stackSize > 0 && stack[stackSize - 1] > num) {
            stackSize--;
        }
        
        // Add current number if it's not zero and not already at stack top
        if (num > 0 && (stackSize == 0 || stack[stackSize - 1] != num)) {
            stack[stackSize++] = num;
        }
    }
    
    free(stack);
    return stackSize;
}

int main() {
    int nums[1000];
    int n = 0;
    char c;
    
    scanf("%c", &c); // [
    if (getchar() != ']') {
        ungetc(getchar(), stdin);
        while (scanf("%d", &nums[n]) == 1) {
            n++;
            scanf("%c", &c); // , or ]
            if (c == ']') break;
        }
    }
    
    printf("%d\n", minimumOperations(nums, n));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through the array, each element pushed/popped at most once

✓ Linear Growth

Space Complexity

O(n)

Stack can contain up to n elements in worst case

⚡ Linearithmic Space

Constraints

1 ≤ nums.length ≤ 10⁵
0 ≤ nums[i] ≤ 10⁹
At least one element in the array is positive
All elements are non-negative integers

42.3K Views

Medium Frequency

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

Input & Output

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Monotonic Stack (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler