Find Maximum Non-decreasing Array Length - Practice Coding Problems

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. Your goal is to create the longest possible non-decreasing array by strategically combining adjacent elements.

Operations Available:
• Select any contiguous subarray
• Replace it with the sum of its elements

Example: Given array [1, 3, 5, 6], if you select subarray [3, 5], the array becomes [1, 8, 6].

Challenge: What's the maximum length of a non-decreasing array you can achieve? A non-decreasing array means each element is greater than or equal to the previous one: arr[i] >= arr[i-1].

Key Insight: You can combine elements to make them larger, but this reduces the array length. The goal is to find the optimal balance!

Input & Output

example_1.py — Basic Case

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

› Output: 3

💡 Note: We can partition as [4] + [3,2] + [6] = [4, 5, 6], which is non-decreasing with length 3.

example_2.py — Already Non-decreasing

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

› Output: 4

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

example_3.py — Single Element

$ Input: [5]

› Output: 1

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

Visualization

Tap to expand

Understanding the Visualization

Start with blocks

Begin with array [4,3,2,6] as building blocks

Try combinations

Consider different ways to combine adjacent blocks

Check ordering

Ensure each level is ≥ the previous level

Maximize height

Find the combination giving the most levels

Key Takeaway

🎯 Key Insight: Use dynamic programming to track the minimum sum needed for each possible length, combined with binary search for efficiency. This transforms an exponential problem into an O(n log n) solution!

Time & Space Complexity

Time Complexity

⏱️

O(n log n)

We process n elements, and for each element we do a binary search over at most n lengths

⚡ Linearithmic

Space Complexity

O(n)

We store prefix sums and DP array, both of size n

⚡ Linearithmic Space

Constraints

1 ≤ nums.length ≤ 10⁵
1 ≤ nums[i] ≤ 10⁹
Array contains only positive integers
Operations can be performed any number of times

Asked in

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

The optimal solution uses Dynamic Programming with Binary Search to achieve O(n log n) time complexity. Key insight: maintain a DP array where dp[i] represents the minimum sum needed to achieve length i, then use binary search to efficiently find the maximum length achievable for each segment sum.

Common Approaches

Approach	Time	Space	Notes
✓ Dynamic Programming with Binary Search (Optimal)	O(n log n)	O(n)	Use DP with binary search to efficiently find the maximum non-decreasing array length
Brute Force (Try All Combinations)	O(2^n)	O(n)	Generate all possible ways to partition the array and check which gives maximum non-decreasing length

Dynamic Programming with Binary Search (Optimal) — Algorithm Steps

Build prefix sum array for O(1) range sum queries
Initialize DP array where dp[i] = minimum sum for length i
For each position, use binary search to find maximum achievable length
Update DP array with the new minimum sum for each length
Return the maximum length achieved

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Create prefix sum and DP arrays

Process

For each position, try all possible segment starts

Use binary search to find maximum achievable length

Update

Update DP with minimum sum for each length

Code -

solution.c — C

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

int min_ll(long long a, long long b) {
    return (a < b) ? a : b;
}

int findMaximumLength(int* nums, int n) {
    if (n == 0) return 0;
    
    // Build prefix sum for O(1) range queries
    long long* prefix = (long long*)calloc(n + 1, sizeof(long long));
    for (int i = 0; i < n; i++) {
        prefix[i + 1] = prefix[i] + nums[i];
    }
    
    // dp[i] = minimum sum to achieve length i
    long long* dp = (long long*)malloc((n + 1) * sizeof(long long));
    for (int i = 0; i <= n; i++) {
        dp[i] = LLONG_MAX;
    }
    dp[0] = 0;
    
    for (int i = 1; i <= n; i++) {
        // Try all possible starts for the segment ending at i
        for (int start = 0; start < i; start++) {
            // Sum of segment [start, i-1]
            long long segmentSum = prefix[i] - prefix[start];
            
            // Find maximum length we can achieve
            int left = 0, right = start;
            int maxLen = 0;
            
            while (left <= right) {
                int mid = (left + right) / 2;
                if (dp[mid] <= segmentSum) {
                    maxLen = mid;
                    left = mid + 1;
                } else {
                    right = mid - 1;
                }
            }
            
            // Update dp for length maxLen + 1
            if (maxLen + 1 <= n) {
                if (segmentSum < dp[maxLen + 1]) {
                    dp[maxLen + 1] = segmentSum;
                }
            }
        }
    }
    
    // Find the maximum length achieved
    int result = 0;
    for (int i = n; i >= 0; i--) {
        if (dp[i] != LLONG_MAX) {
            result = i;
            break;
        }
    }
    
    free(prefix);
    free(dp);
    return result;
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    int nums[1000];
    int n = 0;
    char* token = strtok(line, " \n");
    while (token != NULL) {
        nums[n++] = atoi(token);
        token = strtok(NULL, " \n");
    }
    
    printf("%d\n", findMaximumLength(nums, n));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n log n)

We process n elements, and for each element we do a binary search over at most n lengths

⚡ Linearithmic

Space Complexity

O(n)

We store prefix sums and DP array, both of size n

⚡ Linearithmic Space

Constraints

1 ≤ nums.length ≤ 10⁵
1 ≤ nums[i] ≤ 10⁹
Array contains only positive integers
Operations can be performed any number of times

42.0K Views

Medium-High Frequency

~25 min Avg. Time

1.3K 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 Binary Search (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler