Make Array Non-decreasing - Practice Coding Problems

Make Array Non-decreasing - Problem

Imagine you have an integer array that's currently out of order. You have a special power: you can select any subarray (a contiguous portion) and replace it with a single element equal to the maximum value in that subarray!

Your mission is to use this operation strategically to create the longest possible non-decreasing array. You can perform this operation zero or more times.

Goal: Return the maximum possible size of the array after performing operations such that the resulting array is non-decreasing (each element ≤ next element).

Example: [3, 1, 5, 2, 4] → You could replace [1, 5, 2] with 5 to get [3, 5, 4], then replace [5, 4] with 5 to get [3, 5].

Input & Output

example_1.py — Basic Replacement

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

› Output: 3

💡 Note: Replace [1,5,2] with max value 5 to get [3,5,4]. Then replace [5,4] with 5 to get [3,5]. Final non-decreasing array has length 3.

example_2.py — Already Non-decreasing

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

› Output: 5

💡 Note: Array is already non-decreasing, so no operations needed. Maximum length is 5.

example_3.py — Single Element

$ Input: [5]

› Output: 1

💡 Note: Single element array is always non-decreasing. Maximum length is 1.

Visualization

Tap to expand

Understanding the Visualization

Original Mountains

Start with the original array as mountain peaks

Identify Valleys

Find sections that violate non-decreasing property

Strategic Flattening

Replace problematic sections with their maximum values

Optimal Path

Achieve the longest possible non-decreasing sequence

Key Takeaway

🎯 Key Insight: We can use dynamic programming to explore all possible replacement strategies and find the one that yields the longest non-decreasing sequence.

Time & Space Complexity

Time Complexity

⏱️

O(n² * 2^n)

Memoization helps but still explores exponential states in worst case

⚠ Quadratic Growth

Space Complexity

O(n² * max_value)

Memoization table plus recursion stack

⚠ Quadratic Space

Constraints

1 ≤ nums.length ≤ 10³
1 ≤ nums[i] ≤ 10⁶
The array contains only positive integers

Asked in

G Google 45 a Amazon 38 f Meta 32 ⊞ Microsoft 28

This problem requires finding the longest possible non-decreasing sequence after optimally replacing subarrays with their maximum values. The key insight is using dynamic programming with memoization to explore all replacement possibilities while avoiding redundant calculations. The optimal approach considers each position and decides whether to keep the element or replace a subarray starting from that position.

Common Approaches

Approach	Time	Space	Notes
✓ Dynamic Programming with Memoization	O(n² * 2^n)	O(n² * max_value)	Use recursion with memoization to avoid recomputing the same subproblems

Dynamic Programming with Memoization — Algorithm Steps

Define recursive function with state (current position, previous value)
For each position, try keeping element or starting replacement
Use memoization to cache results
Return maximum length achievable

Visualization

Tap to expand

Step-by-Step Walkthrough

Define States

Each state represents (position, previous_value)

Explore Options

For each position: keep element or replace subarray

Cache Results

Store computed results to avoid recomputation

Return Optimal

Return the maximum length found

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define MAX_SIZE 1000
#define MAX_VAL 100000

typedef struct {
    char key[50];
    int value;
} MemoEntry;

MemoEntry memo[MAX_SIZE];
int memoSize = 0;

int findMemo(char* key) {
    for (int i = 0; i < memoSize; i++) {
        if (strcmp(memo[i].key, key) == 0) {
            return memo[i].value;
        }
    }
    return -1;
}

void addMemo(char* key, int value) {
    strcpy(memo[memoSize].key, key);
    memo[memoSize].value = value;
    memoSize++;
}

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

int findMax(int* nums, int start, int end) {
    int maxVal = nums[start];
    for (int i = start + 1; i < end; i++) {
        if (nums[i] > maxVal) maxVal = nums[i];
    }
    return maxVal;
}

int dp(int* nums, int size, int pos, int prevVal) {
    if (pos == size) return 0;
    
    char key[50];
    sprintf(key, "%d,%d", pos, prevVal);
    
    int cached = findMemo(key);
    if (cached != -1) return cached;
    
    int result = 0;
    
    // Option 1: Keep current element
    if (nums[pos] >= prevVal) {
        result = max(result, 1 + dp(nums, size, pos + 1, nums[pos]));
    }
    
    // Option 2: Replace subarray starting at pos
    for (int end = pos + 1; end <= size; end++) {
        int subarrayMax = findMax(nums, pos, end);
        if (subarrayMax >= prevVal) {
            result = max(result, 1 + dp(nums, size, end, subarrayMax));
        }
    }
    
    addMemo(key, result);
    return result;
}

int solution(int* nums, int size) {
    memoSize = 0;
    return dp(nums, size, 0, -MAX_VAL);
}

int main() {
    int nums[] = {3, 1, 5, 2, 4};
    printf("%d\n", solution(nums, 5));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n² * 2^n)

Memoization helps but still explores exponential states in worst case

⚠ Quadratic Growth

Space Complexity

O(n² * max_value)

Memoization table plus recursion stack

⚠ Quadratic Space

Constraints

1 ≤ nums.length ≤ 10³
1 ≤ nums[i] ≤ 10⁶
The array contains only positive integers

23.8K Views

Medium Frequency

~25 min Avg. Time

892 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

Dynamic Programming with Memoization — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler