Find Maximum Non-decreasing Array Length

Find Maximum Non-decreasing Array Length - Problem

Array Binary Search Dynamic Programming Stack Queue Monotonic Stack Monotonic Queue Hard

You are given a 0-indexed integer array nums. You can perform any number of operations, where each operation involves selecting a subarray of the array and replacing it with the sum of its elements.

For example, if the given array is [1,3,5,6] and you select subarray [3,5], the array will convert to [1,8,6].

Return the maximum length of a non-decreasing array that can be made after applying operations.

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

Input & Output

Example 1 — Basic Merging

$ Input: nums = [5,2,4,6,3,7]

› Output: 3

💡 Note: We can merge subarrays: [5] + [2,4] + [6,3,7] = [5,6,16]. This gives us a non-decreasing array of length 3.

Example 2 — Already Non-decreasing

$ Input: nums = [1,3,5,6]

› Output: 4

💡 Note: Array is already non-decreasing, so no merging needed. Keep all elements: [1,3,5,6]. Length is 4.

Example 3 — Single Element

$ Input: nums = [1]

› Output: 1

💡 Note: Single element is always non-decreasing. No operations needed. Length is 1.

Constraints

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

Visualization

Tap to expand

Asked in

G Google 15 a Amazon 12 f Meta 8 M Microsoft 6

The key insight is to use a monotonic stack to greedily merge subarrays when needed to maintain the non-decreasing property. The optimal stack-based approach processes elements left to right, merging with previous sums when the current sum would violate non-decreasing order. Time: O(n), Space: O(n)

Common Approaches

✓ Brute Force - Try All Possible Subarrays

⏱️ Time: O(2ⁿ × n) Space: O(n)

For each possible way to partition the array, replace each subarray with its sum and check if the result is non-decreasing. Track the maximum length found.

Dynamic Programming with Binary Search

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

For each position, try all possible starting points of subarrays ending at current position. Use binary search to find valid previous positions that maintain non-decreasing property.

Monotonic Stack - Greedy Approach

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

Process elements left to right. Use a stack to maintain non-decreasing sums by merging consecutive elements when the current sum would violate the non-decreasing property.

Brute Force - Try All Possible Subarrays — Algorithm Steps

Generate all possible partitions of the array
For each partition, compute subarray sums
Check if sums form non-decreasing sequence
Track maximum valid length

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Partitions

Try all ways to split [5,2,4,6,3,7]

Compute Sums

Replace each subarray with its sum

Check Non-decreasing

Verify if sums form non-decreasing sequence

Code -

solution.c — C

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

static long long stack[1000];
static int stackSize;

int solution(int* nums, int n) {
    if (n == 0) {
        return 0;
    }
    
    stackSize = 0;
    long long currentSum = 0;
    
    for (int i = 0; i < n; i++) {
        currentSum += nums[i];
        
        // While stack is not empty and top element > current_sum
        // merge the top with current sum
        while (stackSize > 0 && stack[stackSize - 1] > currentSum) {
            currentSum += stack[stackSize - 1];
            stackSize--;
        }
        
        stack[stackSize++] = currentSum;
        currentSum = 0;
    }
    
    return stackSize;
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    // Parse array manually
    static int nums[1000];
    int n = 0;
    char* p = line;
    
    // Skip to first '['
    while (*p && *p != '[') p++;
    if (*p == '[') p++;
    
    // Parse numbers
    while (*p && *p != ']') {
        while (*p == ' ' || *p == ',') p++;
        if (*p == ']' || *p == '\0') break;
        nums[n++] = (int)strtol(p, &p, 10);
    }
    
    int result = solution(nums, n);
    printf("%d\n", result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(2ⁿ × n)

2^n possible partitions, each requiring O(n) time to compute and validate

⚠ Quadratic Growth

Space Complexity

O(n)

Recursion stack and temporary arrays to store current partition

⚡ Linearithmic Space

8.5K Views

Medium Frequency

~25 min Avg. Time

234 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 Possible Subarrays — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler