Make Array Non-decreasing

Make Array Non-decreasing - Problem

You are given an integer array nums. In one operation, you can select a subarray and replace it with a single element equal to its maximum value.

Return the maximum possible size of the array after performing zero or more operations such that the resulting array is non-decreasing.

A subarray is a contiguous sequence of elements within an array.

Input & Output

Example 1 — Basic Case

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

› Output: 1

💡 Note: We can replace the entire array [3,4,2,1] with its maximum value 4, resulting in [4] which is non-decreasing and has length 1.

Example 2 — Already Non-decreasing

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

› Output: 4

💡 Note: The array is already non-decreasing, so no operations are needed. The maximum length is 4.

Example 3 — Partial Replacement

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

› Output: 3

💡 Note: Replace subarray [3,2] with 3, resulting in [1,3,4] which is non-decreasing with length 3.

Constraints

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

Visualization

Tap to expand

Asked in

G Google 35 a Amazon 28 M Microsoft 22 🍎 Apple 18

The key insight is to use a monotonic stack to maintain the longest possible non-decreasing sequence. When we encounter an element smaller than the stack top, we can merge the larger elements with it. Best approach uses greedy monotonic stack in O(n) time and O(n) space.

Common Approaches

✓ Brute Force - Try All Combinations

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

Try every possible combination of subarray replacements. For each combination, replace each selected subarray with its maximum value and check if the result is non-decreasing.

Greedy with Monotonic Stack

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

Process elements from left to right. Use a stack to keep track of elements in non-decreasing order. When we encounter an element smaller than the stack top, we can merge previous elements.

Brute Force - Try All Combinations — Algorithm Steps

Generate all possible subarray combinations
For each combination, replace subarrays with their maximum
Check if result is non-decreasing
Return maximum length found

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Combinations

Create all possible ways to group elements

Replace with Max

Replace each subarray with its maximum value

Check Valid

Verify if result is non-decreasing

Code -

solution.c — C

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

int countSubsequences(char* s, char* p) {
    if (p[0] == p[1]) {
        int count = 0;
        for (int j = 0; s[j]; j++) {
            if (s[j] == p[0]) count++;
        }
        return count * (count - 1) / 2;
    }
    
    int countFirst = 0;
    int total = 0;
    for (int j = 0; s[j]; j++) {
        if (s[j] == p[0]) {
            countFirst++;
        } else if (s[j] == p[1]) {
            total += countFirst;
        }
    }
    return total;
}

int solution(char* text, char* pattern) {
    int maxCount = 0;
    int n = strlen(text);
    char* modified = (char*)malloc((n + 2) * sizeof(char));
    
    // Try inserting pattern[0] at each position
    for (int i = 0; i <= n; i++) {
        strncpy(modified, text, i);
        modified[i] = pattern[0];
        strcpy(modified + i + 1, text + i);
        int count = countSubsequences(modified, pattern);
        if (count > maxCount) maxCount = count;
    }
    
    // Try inserting pattern[1] at each position
    for (int i = 0; i <= n; i++) {
        strncpy(modified, text, i);
        modified[i] = pattern[1];
        strcpy(modified + i + 1, text + i);
        int count = countSubsequences(modified, pattern);
        if (count > maxCount) maxCount = count;
    }
    
    free(modified);
    return maxCount;
}

int main() {
    char text[100001], pattern[3];
    fgets(text, sizeof(text), stdin);
    fgets(pattern, sizeof(pattern), stdin);
    text[strcspn(text, "\n")] = 0;
    pattern[strcspn(pattern, "\n")] = 0;
    printf("%d\n", solution(text, pattern));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(2^n)

Each subarray can be either replaced or not, leading to exponential combinations

✓ Linear Growth

Space Complexity

O(n)

Recursion stack and temporary arrays for each combination

⚡ Linearithmic Space

32.4K Views

Medium Frequency

~25 min Avg. Time

890 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

Brute Force - Try All Combinations — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler