Max Chunks To Make Sorted II

Max Chunks To Make Sorted II - Problem

You are given an integer array arr. We split arr into some number of chunks (i.e., partitions), and individually sort each chunk. After concatenating them, the result should equal the sorted array.

Return the largest number of chunks we can make to sort the array.

Input & Output

Example 1 — Basic Case

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

› Output: 1

💡 Note: The array is already in reverse order. No matter how we split it, we need all elements together to form the sorted sequence [1,2,3,4,5]. Only 1 chunk is possible.

Example 2 — Multiple Chunks Possible

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

› Output: 4

💡 Note: We can split as [2,1] | [3] | [4] | [4]. After sorting each chunk: [1,2] + [3] + [4] + [4] = [1,2,3,4,4], which matches the sorted array.

Example 3 — Already Sorted

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

› Output: 5

💡 Note: Array is already sorted, so we can make each element its own chunk: [1] | [2] | [3] | [4] | [5]. Maximum possible chunks.

Constraints

1 ≤ arr.length ≤ 2000
0 ≤ arr[i] ≤ 10⁸

Visualization

Tap to expand

Asked in

G Google 42 a Amazon 28 f Facebook 15 M Microsoft 12

The key insight is that we can make a cut after position i if the maximum element in positions 0 to i equals the (i+1)th smallest element overall. The monotonic stack approach is optimal with O(n) time and elegantly handles merging chunks when smaller elements appear. Alternative greedy approach takes O(n log n) but is simpler to understand.

Common Approaches

✓ Dp 1d

⏱️ Time: N/A Space: N/A

Brute Force - Try All Partitions

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

For each possible way to split the array into chunks, sort each chunk and check if concatenating them gives the sorted array. Return the maximum number of chunks that works.

Greedy Approach with Prefix Analysis

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

Compare prefix maximums of the original array with the sorted array. We can make a cut at position i if the maximum element in the first i+1 positions equals the (i+1)th largest element overall.

Monotonic Stack Approach

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

Maintain a stack of chunk maximums. When we encounter an element smaller than the top of stack, it means we need to merge chunks. Keep merging until we can place the current element.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

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

long long solution(int* nums, int numsSize) {
    long long even = 0; // Can start new or extend by adding
    long long odd = 0;  // Can extend by subtracting
    
    for (int i = 0; i < numsSize; i++) {
        long long newEven = max(even, odd + nums[i]);
        long long newOdd = max(odd, even - nums[i]);
        even = newEven;
        odd = newOdd;
    }
    
    return even;
}

int main() {
    char line[100000];
    fgets(line, sizeof(line), stdin);
    
    int nums[10000];
    int size = 0;
    char* token = strtok(line, "[,]");
    while (token != NULL) {
        nums[size++] = atoi(token);
        token = strtok(NULL, "[,]");
    }
    
    long long result = solution(nums, size);
    printf("%lld\n", result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

⚡ Linearithmic

Space Complexity

⚡ Linearithmic Space

89.3K Views

Medium-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