Max Chunks To Make Sorted II - Practice Coding Problems

Max Chunks To Make Sorted II - Problem

Imagine you have an array of integers that needs to be sorted, but instead of sorting it directly, you want to split it into chunks first. Each chunk can be sorted independently, and when you concatenate all the sorted chunks together, the result should be identical to sorting the entire array at once.

Your goal: Find the maximum number of chunks you can create while still achieving a perfectly sorted final array.

Key insight: Unlike the simpler version of this problem, this array can contain duplicate values and the values are not restricted to be a permutation of indices.

Example: For array [2,1,3,4,4], you could split it as [2,1] | [3] | [4,4]. After sorting each chunk: [1,2] + [3] + [4,4] = [1,2,3,4,4], which matches the fully sorted array. This gives us 3 chunks, which is the maximum possible.

Input & Output

example_1.py — Basic Case

$ Input: [5,4,3,8,8]

› Output: 3

💡 Note: We can split into [5,4,3] | [8] | [8]. After sorting each chunk: [3,4,5] + [8] + [8] = [3,4,5,8,8], which equals the fully sorted array. This gives us 3 chunks, which is maximum possible.

example_2.py — All Same Elements

$ Input: [2,2,2,2]

› Output: 4

💡 Note: Since all elements are the same, we can split into individual chunks: [2] | [2] | [2] | [2]. Each chunk is already sorted, and concatenating gives [2,2,2,2]. Maximum chunks = 4.

example_3.py — Already Sorted

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

› Output: 4

💡 Note: Array is already sorted, so we can split into individual elements: [1] | [2] | [3] | [4]. Each single-element chunk is trivially sorted. Maximum chunks = 4.

Visualization

Tap to expand

Understanding the Visualization

Identify Break Points

You can only create a new pile when the largest book in current piles won't interfere with future books

Use Stack of Maximums

Keep track of the largest book title in each pile using a stack

Merge When Necessary

If a new book has a title that comes before books in existing piles, you must merge those piles

Count Final Piles

The number of separate piles (stack size) is your answer

Key Takeaway

🎯 Key Insight: We can split after position i only if the maximum value in all chunks up to i won't interfere with future elements. The monotonic stack elegantly tracks these chunk maximums and merges when necessary.

Time & Space Complexity

Time Complexity

⏱️

O(n² × 2ⁿ)

2^(n-1) partitions to try, each requiring O(n log n) sorting and O(n) comparison

⚠ Quadratic Growth

Space Complexity

O(n)

Space for storing chunks and sorted arrays

⚡ Linearithmic Space

Constraints

1 ≤ arr.length ≤ 2000
0 ≤ arr[i] ≤ 10⁸
Array elements can be duplicated (unlike the simpler version)
Array elements are not restricted to be permutations of indices

Asked in

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

The optimal solution uses a monotonic stack to track the maximum value of each chunk. As we process each element, if it's smaller than the stack top, we merge chunks by popping from the stack and keeping track of the maximum value. The final stack size equals the maximum number of chunks. Time: O(n), Space: O(n).

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Try All Partitions)	O(n² × 2ⁿ)	O(n)	Generate all possible ways to partition the array and check which ones work
Monotonic Stack (Optimal)	O(n)	O(n)	Use a stack to track chunk maximums and merge when necessary

Brute Force (Try All Partitions) — Algorithm Steps

Generate all possible partition points using bit manipulation
For each partition, split the array into chunks
Sort each chunk individually
Concatenate all sorted chunks
Check if result equals the fully sorted original array
Keep track of the maximum number of chunks that work

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Partitions

Use bitmask to create all possible ways to split the array

Sort Each Chunk

Sort each partition individually

Concatenate & Compare

Join sorted chunks and compare with fully sorted array

Track Maximum

Keep the partition with the most chunks that works

Code -

solution.c — C

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

int compare(const void *a, const void *b) {
    return (*(int*)a - *(int*)b);
}

int maxChunksToSorted(int* arr, int n) {
    int* sortedArr = (int*)malloc(n * sizeof(int));
    memcpy(sortedArr, arr, n * sizeof(int));
    qsort(sortedArr, n, sizeof(int), compare);
    
    int maxChunks = 0;
    
    // Try all possible partitions
    for (int mask = 0; mask < (1 << (n-1)); mask++) {
        int* result = (int*)malloc(n * sizeof(int));
        int resultIdx = 0;
        int start = 0;
        int numChunks = 0;
        
        // Process chunks based on bitmask
        for (int i = 0; i < n-1; i++) {
            if (mask & (1 << i)) {
                // Sort chunk from start to i
                int chunkSize = i - start + 1;
                int* chunk = (int*)malloc(chunkSize * sizeof(int));
                for (int j = 0; j < chunkSize; j++) {
                    chunk[j] = arr[start + j];
                }
                qsort(chunk, chunkSize, sizeof(int), compare);
                
                // Add to result
                for (int j = 0; j < chunkSize; j++) {
                    result[resultIdx++] = chunk[j];
                }
                
                free(chunk);
                start = i + 1;
                numChunks++;
            }
        }
        
        // Handle last chunk
        int lastChunkSize = n - start;
        int* lastChunk = (int*)malloc(lastChunkSize * sizeof(int));
        for (int j = 0; j < lastChunkSize; j++) {
            lastChunk[j] = arr[start + j];
        }
        qsort(lastChunk, lastChunkSize, sizeof(int), compare);
        
        for (int j = 0; j < lastChunkSize; j++) {
            result[resultIdx++] = lastChunk[j];
        }
        free(lastChunk);
        numChunks++;
        
        // Check if result matches sorted array
        int matches = 1;
        for (int i = 0; i < n; i++) {
            if (result[i] != sortedArr[i]) {
                matches = 0;
                break;
            }
        }
        
        if (matches && numChunks > maxChunks) {
            maxChunks = numChunks;
        }
        
        free(result);
    }
    
    free(sortedArr);
    return maxChunks;
}

int main() {
    int arr[1000];
    int n = 0;
    char c;
    
    scanf("%c", &c); // Read '['
    while (scanf("%d%c", &arr[n], &c)) {
        n++;
        if (c == ']') break;
    }
    
    printf("%d\n", maxChunksToSorted(arr, n));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n² × 2ⁿ)

2^(n-1) partitions to try, each requiring O(n log n) sorting and O(n) comparison

⚠ Quadratic Growth

Space Complexity

O(n)

Space for storing chunks and sorted arrays

⚡ Linearithmic Space

Constraints

1 ≤ arr.length ≤ 2000
0 ≤ arr[i] ≤ 10⁸
Array elements can be duplicated (unlike the simpler version)
Array elements are not restricted to be permutations of indices

52.0K 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

Input & Output

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Brute Force (Try All Partitions) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler