Max Chunks To Make Sorted

LeetCode 768. Max Chunks To Make Sorted I

Given an array arr of integers (not necessarily distinct), we split the array into some number of "chunks" (partitions), and individually sort each chunk.  After concatenating them, the result equals the sorted array.

What is the most number of chunks we could have made?

意思就是，对一个数组进行分组（不能交换元素顺序），分好组之后进行组内排序，连接之后得到的结果和直接对原数组排序的结果一致。问最多可以把数组分成几组？

这个回答 思路很清晰，复杂度为 $O(n)$

笔试碰到了一样的题目，自己只想到了找右边最小元素，却忘了和已成组的最大值进行比较

也学到了用栈来保存右侧最小元素的方法

/**
 * 来源：https://leetcode.com/problems/max-chunks-to-make-sorted-ii/discuss/167259/Two-Java-O(n)-Solutions-with-Explanation-min-array-and-stack
 */
public int maxChunksToSorted(int[] arr) {
    int n = arr.length;
    Stack<Integer> smallest = new Stack<Integer>();
    for (int i = n-1; i >= 0; i--) {
        if (smallest.isEmpty() || arr[i] <= smallest.peek())
            smallest.push(arr[i]);
    }
    int largest = arr[0];
    int ret = 0;
    for (int i = 0; i < n-1; i++) {
        if (arr[i] == smallest.peek())
            smallest.pop();
        largest = Math.max(largest, arr[i]);
        if (largest <= smallest.peek()) {
            ret++;
            largest = arr[i+1];
        }
    }
    return ret+1;
}

 类似的，也可以将右侧的最小值保存在一个数组里

public int maxChunksToSorted(int[] arr) {
    int len = arr.length;
    int[] minRight = new int[len];

    int maxLeft = arr[0];

    minRight[len - 1] = arr[len - 1];
    for (int i = len - 2; i >= 0; i--) {
        minRight[i] = Math.min(minRight[i + 1], arr[i + 1]);
    }

    int count = 1;
    for (int i = 0; i < len - 1; i++) {
        if (maxLeft <= minRight[i]) {
            count++;
        }
        maxLeft = Math.max(maxLeft, arr[i + 1]);
    }

    return count;
}