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 task is to apply some (possibly zero) operations on the array so that all elements become 0.

In one operation, you can select a subarray [i, j] (where 0 <= i <= j < n) and set all occurrences of the minimum non-negative integer in that subarray to 0.

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

Input & Output

Example 1 — Basic Case

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

› Output: 7

💡 Note: Using the greedy approach: Position 0 (value 2) needs 1 operation. Position 1 (value 1) needs 1 operation (pops 2 from stack). Position 2 (value 3) needs 2 operations. Position 3 (value 4) needs 3 operations. Total: 1+1+2+3 = 7 operations.

Example 2 — All Same Elements

$ Input: nums = [3,3,3]

› Output: 3

💡 Note: Each element requires exactly 1 operation since they're all the same value. Total: 3 operations.

Example 3 — Already Zero

$ Input: nums = [0,0,0]

› Output: 0

💡 Note: All elements are already zero, so no operations are needed.

Constraints

1 ≤ nums.length ≤ 10⁵
0 ≤ nums[i] ≤ 10⁹

Visualization

Tap to expand

Asked in

G Google 15 a Amazon 12 M Microsoft 8

The key insight is that each element requires as many operations as there are smaller elements to its left plus one. The optimal approach uses a monotonic stack to efficiently count these smaller elements in O(n) time. Time: O(n), Space: O(n)

Common Approaches

✓ Monotonic Stack Approach

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

The key insight is that an element needs as many operations as there are smaller elements to its left plus one. We can use a monotonic stack to efficiently compute this.

Simulation Approach

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

For each operation, scan the entire array to find the minimum non-zero value, then remove all occurrences of it. Continue until all elements are zero.

Monotonic Stack Approach — Algorithm Steps

Traverse array from left to right
Use monotonic stack to track elements smaller than current
For each element, operations needed = stack size + 1
Sum all operations

Visualization

Tap to expand

Step-by-Step Walkthrough

Process Elements

For each element, count smaller elements to its left

Stack Operations

Maintain monotonic stack of increasing elements

Calculate Operations

Operations = stack size + 1 for each element

Code -

solution.c — C

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

static int stack[100000];

int solution(int* nums, int n) {
    int stackTop = -1;
    int operations = 0;
    
    for (int i = 0; i < n; i++) {
        // Skip elements that are already 0
        if (nums[i] == 0) {
            continue;
        }
        
        // Remove elements from stack that are >= current element
        while (stackTop >= 0 && stack[stackTop] >= nums[i]) {
            stackTop--;
        }
        
        // Current element needs (stackTop + 1) + 1 operations
        operations += stackTop + 2;
        
        // Add current element to stack
        stack[++stackTop] = nums[i];
    }
    
    return operations;
}

int main() {
    char line[1000000];
    fgets(line, sizeof(line), stdin);
    line[strcspn(line, "\n")] = 0;
    
    // Parse array manually
    int nums[100000];
    int n = 0;
    char* p = line;
    
    // Skip to first '['
    while (*p && *p != '[') p++;
    if (*p == '[') p++;
    
    // Parse numbers
    while (*p && *p != ']') {
        // Skip whitespace and commas
        while (*p == ' ' || *p == ',') p++;
        if (*p == ']' || *p == '\0') break;
        
        // Parse number
        char* endptr;
        long val = strtol(p, &endptr, 10);
        if (endptr != p) {
            nums[n++] = (int)val;
            p = endptr;
        } else {
            p++;
        }
    }
    
    int result = solution(nums, n);
    printf("%d\n", result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through array with each element pushed/popped from stack at most once

✓ Linear Growth

Space Complexity

O(n)

Monotonic stack can store up to n elements in worst case

⚡ Linearithmic Space

18.5K Views

Medium Frequency

~25 min Avg. Time

847 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

Monotonic Stack Approach — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler