Steps to Make Array Non-decreasing - Practice Coding Problems

Steps to Make Array Non-decreasing - Problem

You're given a 0-indexed integer array nums that might contain elements in decreasing order. Your task is to make this array non-decreasing by repeatedly removing problematic elements.

In each step, you must simultaneously remove all elements nums[i] where nums[i - 1] > nums[i] for all valid indices 0 < i < nums.length. Think of this as a "filtering" process where smaller elements that come after larger elements get eliminated in each round.

Goal: Return the number of steps required until the array becomes non-decreasing (i.e., each element is greater than or equal to the previous element).

Example: [5, 3, 4, 4, 7, 3, 6, 11, 8, 5, 11]
Step 1: Remove 3, 3, 8, 5 → [5, 4, 4, 7, 6, 11, 11]
Step 2: Remove 4, 4, 6 → [5, 7, 11, 11]
Step 3: Remove 5 → [7, 11, 11]
Total: 3 steps

Input & Output

example_1.py — Basic Case

$ Input: [5, 3, 4, 4, 7, 3, 6, 11, 8, 5, 11]

› Output: 3

💡 Note: Step 1: Remove [3,3,8,5] → [5,4,4,7,6,11,11]. Step 2: Remove [4,4,6] → [5,7,11,11]. Step 3: Remove [5] → [7,11,11]. Total: 3 steps.

example_2.py — Already Sorted

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

› Output: 0

💡 Note: Array is already non-decreasing, so no steps needed.

example_3.py — Reverse Order

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

› Output: 3

💡 Note: Step 1: Remove [3,2,1] → [4]. Step 2: Remove [2,1] → [3]. Step 3: Remove [1] → [2]. Final result: [4] but we need 3 steps to eliminate everything except the maximum element.

Constraints

1 ≤ nums.length ≤ 10⁵
1 ≤ nums[i] ≤ 10⁹
Array elements can be equal (non-decreasing, not strictly increasing)

Visualization

Tap to expand

Understanding the Visualization

Initial State

Array has elements of varying heights like rocks in a waterfall

Identify Blocks

Find all positions where flow is blocked (decreasing elements)

Simultaneous Removal

All blocking elements are removed at once

Repeat Process

Continue until water can flow smoothly (non-decreasing array)

Key Takeaway

🎯 Key Insight: Use a monotonic stack to track 'survivor rounds' - each element knows when it will be eliminated based on conflicts with previous elements!

Asked in

G Google 42 a Amazon 38 f Meta 29 ⊞ Microsoft 31

The optimal solution uses a monotonic stack to efficiently simulate the elimination process. Instead of repeatedly scanning the array, we track how many steps each element survives by maintaining a stack of (value, elimination_round) pairs. When processing each element, we pop conflicting elements from the stack and calculate the maximum elimination rounds needed. This reduces time complexity from O(n²) to O(n).

Common Approaches

Approach	Time	Space	Notes
✓ Monotonic Stack (Optimal)	O(n)	O(n)	Use a stack to efficiently track elimination rounds for each element
Simulation (Brute Force)	O(n²)	O(n)	Directly simulate the elimination process step by step

Monotonic Stack (Optimal) — Algorithm Steps

Initialize an empty stack and result variable
For each element in the array:
- While stack is not empty and stack.top >= current element:
- Pop from stack and update the maximum steps needed
- Push current element with its elimination round to stack
Return the maximum steps found

Visualization

Tap to expand

Step-by-Step Walkthrough

Process Element

For each element, determine conflicts with stack top

Pop Conflicts

Remove larger elements and calculate elimination steps

Push Element

Add current element with its elimination round

Track Maximum

Keep track of the maximum steps needed

Code -

solution.c — C

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

typedef struct {
    int value;
    int steps;
} Element;

int max(int a, int b) {
    return a > b ? a : b;
}

int waysToMakeArrayNonDecreasing(int* nums, int numsSize) {
    if (numsSize == 0) return 0;
    
    Element* stack = (Element*)malloc(numsSize * sizeof(Element));
    int stackSize = 0;
    int maxSteps = 0;
    
    for (int i = 0; i < numsSize; i++) {
        int num = nums[i];
        int steps = 0;
        
        // Remove all elements that are >= current number
        while (stackSize > 0 && stack[stackSize-1].value >= num) {
            // The steps to eliminate current num is at least
            // 1 + steps needed to eliminate the conflicting element
            steps = max(steps, stack[stackSize-1].steps + 1);
            stackSize--;
        }
        
        stack[stackSize].value = num;
        stack[stackSize].steps = steps;
        stackSize++;
        
        maxSteps = max(maxSteps, steps);
    }
    
    free(stack);
    return maxSteps;
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    // Parse array from input
    int nums[1000];
    int numsSize = 0;
    
    char* token = strtok(line, "[,]");
    while (token != NULL && numsSize < 1000) {
        nums[numsSize++] = atoi(token);
        token = strtok(NULL, "[,]");
    }
    
    printf("%d\n", waysToMakeArrayNonDecreasing(nums, numsSize));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Each element is pushed and popped at most once from the stack

✓ Linear Growth

Space Complexity

O(n)

Stack can contain at most n elements in worst case

⚡ Linearithmic Space

43.4K Views

High Frequency

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

Constraints

Visualization

Related Problems

Common Approaches

Monotonic Stack (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler