LeetCode 768. 最多能完成排序的块 II 贪心 + 单调栈 + 前缀和

题目描述

这个问题和“最多能完成排序的块”相似，但给定数组中的元素可以重复，输入数组最大长度为2000，其中的元素最大为10**8。

arr是一个可能包含重复元素的整数数组，我们将这个数组分割成几个“块”，并将这些块分别进行排序。之后再连接起来，使得连接的结果和按升序排序后的原数组相同。

我们最多能将数组分成多少块？

示例 1:

输入: arr = [5,4,3,2,1]
输出: 1
解释:
将数组分成2块或者更多块，都无法得到所需的结果。
例如，分成 [5, 4], [3, 2, 1] 的结果是 [4, 5, 1, 2, 3]，这不是有序的数组。
示例 2:

输入: arr = [2,1,3,4,4]
输出: 4
解释:
我们可以把它分成两块，例如 [2, 1], [3, 4, 4]。
然而，分成 [2, 1], [3], [4], [4] 可以得到最多的块数。
注意:

arr的长度在[1, 2000]之间。
arr[i]的大小在[0, 10**8]之间。

来源：力扣（LeetCode）
链接：https://leetcode.cn/problems/max-chunks-to-make-sorted-ii
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

思路

参考：https://www.acwing.com/solution/content/131943/

1，贪心

class Solution {
public:
    int maxChunksToSorted(vector<int>& arr) {
        /*
            要求划分的区间尽可能地多，那么我们从左到右进行处理，遇到满足条件的就贪心地分成一个组，具体的证明可以反过来想一想。
        */
        unordered_map<int, int> cnt; // 用于计数
        int res = 0;
        vector<int> Sort = arr; // Sort不能用小写开头，和关键字重名了
        sort(Sort.begin(), Sort.end());

        for (int i = 0; i < arr.size(); i ++ ) {
            int a = arr[i], b = Sort[i];
            //
            cnt[a] ++ ;
            // 如果这个数组没有了，则在这个计数数组中删除它
            if (!cnt[a]) cnt.erase(a);
            cnt[b] -- ;
            if (!cnt[b]) cnt.erase(b);
            // 如果没元素了，则更新答案
            if (cnt.size() == 0) res ++ ;
        } 

        return res;
    }
};

2、单调栈

对于分好区间的数组，我们容易得到：左边的区间的所有数字均小于等于右边的区间的所有数字。
接下来，我们考虑在数组末尾加上一个数字后分出区间的变化：

• 如果新加入的数字大于等于末尾区间的最大值，则它可以自成一个区间。
• 如果新加入的数字小于末尾区间的最大值，则它必须要融入到之前的区间中，判断它是否大于等于倒数第二个区间的最大值，如果满足，停止操作；如果不满足间，继续往后判断。

上述操作满足单调性，且是从右往左操作，可以使用单调栈实现。

class Solution {
public:
    int maxChunksToSorted(vector<int>& arr) {

        stack<int> s;
        for (auto i : arr) {
            // 自成一个区间
            if (s.empty() || s.top() <= i) s.push(i);
            else {
                // 先取出来最大值
                int maxn = s.top();
                // 走掉
                s.pop();
                // 往前找，直到栈为空或者是找到了满足要求的位置
                while (s.size() && s.top() > i) s.pop();
                // 最大值再回来
                s.push(maxn);
            }
        }
        // 最后栈的长度就是区间的个数
        return s.size();
    }
};

3、前缀和

如果 arrarr 数组的某一个子串和 SortSort 数组对应子串的和相同，那就说明他们的词频相同，答案加一。这个想法太牛了。

class Solution {
public:
    int maxChunksToSorted(vector<int>& arr) {
        vector<int> Sort = arr;
        sort(Sort.begin(), Sort.end());
        long long sum = 0, Ssum = 0; // 要开long long！！！
        int res = 0;
        for (int i = 0; i < arr.size(); i ++ )
        {
            sum += arr[i]; // arr数组的前缀和
            Ssum += Sort[i]; // Sort数组的前缀和
            if (sum == Ssum) res ++ ; // 词频相同，答案加一
        }
        return res;
    }
};