完美世界

近日，游戏大厂「完美世界」被曝进行大规模裁员。

完美世界，最大规模裁员_完美世界

据爆料指出，隔天来上班，就有几个工位就空了，从刚开始的"零星几个"的工位被空出，到如今的范围越来越大，基本上"整层整层"的空出。

如今公司也出现了一些其他声音：剩下的项目，一只手都能数得过来，已经很难被称为大厂了、这是完美有史以来最大规模的优化了 ...

更加讽刺的是，职场 App 上一些完美世界的员工现身说法：

完美世界，最大规模裁员_完美世界_02

带着完美世界员工认证身份的网友指出：混子都留着呢，干活的反而被裁了。

完美世界，最大规模裁员_后端_03

不少声音指出，完美世界内部的关系户实在大多，本次裁员大概率又是「劣币淘汰良币」的过程。

遥想此前阿里马老师的内部信，看来"大厂病"还并非个别现象。

对此你怎么看？在市场被几个现象级手游瓜分的如今，你是否还对完美世界有印象？

...

回归主题。

来一道和「米哈游（原神）」相关的算法原题。

题目描述

平台：LeetCode

题号：768

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

arr 是一个可能包含重复元素的整数数组，我们将这个数组分割成几个“块”，并将这些块分别进行排序。

之后再连接起来，使得连接的结果和按升序排序后的原数组相同。

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

示例 1:

输入: arr = [5,4,3,2,1]

输出: 1

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

示例 2:

输入: arr = [2,1,3,4,4]

输出: 4

解释:
我们可以把它分成两块，例如 [2, 1], [3, 4, 4]。
然而，分成 [2, 1], [3], [4], [4] 可以得到最多的块数。
  • 1.
  • 2.
  • 3.
  • 4.
  • 5.
  • 6.
  • 7.

注意:

  • arr 的长度在 完美世界，最大规模裁员_前端_04
  • arr[i] 的大小在 完美世界，最大规模裁员_完美世界_05

贪心 + 构造

一种容易想到的构造方法，是与目标序列（已排升序的数组 clone）做区间比较。

由于题目要求尽可能划分出多的区间，我们可以从前往后处理 arr 和 clone 时统计区间内数的情况，若有 arr[i...j] 和 clone[i...j] 词频完全相同，可知 arr[i...j] 可通过内部排序调整为 clone[i...j]，此时我们将范围 完美世界，最大规模裁员_后端_06

容易证明该做法的正确性：可从边界开始进行归纳分析，起始两者均从下标为 0 的位置进行扫描。假设最优解和贪心解的第一个区间的结束位置相同，问题就会归结到子问题上（即双方均从相同的子数组起始位置开始构造），因此无须额外证明；而当起始位置相同，结束位置不同时，假设分别为 完美世界，最大规模裁员_面试_07 和 完美世界，最大规模裁员_后端_08，则必然有 完美世界，最大规模裁员_数组_09（因为如果有 完美世界，最大规模裁员_数组_10，那么在 完美世界，最大规模裁员_面试_11 扫描到前者时已经满足划分区间的条件，已经会停下来，即与贪心决策逻辑冲突），而当 完美世界，最大规模裁员_数组_09 时，我们可以将最优解中的区间 完美世界，最大规模裁员_面试_07 进一步划分为 完美世界，最大规模裁员_后端_14 和 完美世界，最大规模裁员_数组_15

根据数值之间满足严格全序，可知当 完美世界，最大规模裁员_数组_09 和 完美世界，最大规模裁员_数组_10 均不满足时，必然有 完美世界，最大规模裁员_前端_18

综上，我们证明了对于相同起点，贪心解与最优解结束位置必然相同，从而证明贪心解区间数与最优解相等。

于是原问题转换为如何快速对两数组（原数组 arr 和目标数组 clone）进行词频比较，由于数值的范围为 10^8，如果使用最裸的词频对比方案的话，需要先进行离散化，最终算法的复杂度为 完美世界，最大规模裁员_完美世界_19。

更好的解决方案是使用哈希表进行计数，同时维护当前计数不为 0 的数值数量 tot。

具体的，当我们处理 完美世界，最大规模裁员_完美世界_20 时，我们在哈希表中对 完美世界，最大规模裁员_完美世界_20 进行计数加一，而在处理 完美世界，最大规模裁员_后端_22 时，对 完美世界，最大规模裁员_后端_22 进行计数减一。从而将词频比较的复杂度从 完美世界，最大规模裁员_数组_24 下降到 完美世界，最大规模裁员_后端_25。

Java 代码：

class Solution {
    public int maxChunksToSorted(int[] arr) {
        int[] clone = arr.clone();
        Arrays.sort(clone);
        int n = arr.length, ans = 0;
        Map<Integer, Integer> map = new HashMap<>();
        for (int i = 0, tot = 0; i < n; i++) {
            int a = arr[i], b = clone[i];
            if (map.getOrDefault(a, 0) == -1) tot--;
            else if (map.getOrDefault(a, 0) == 0) tot++;
            map.put(a, map.getOrDefault(a, 0) + 1);
            if (map.getOrDefault(b, 0) == 1) tot--;
            else if (map.getOrDefault(b, 0) == 0) tot++;
            map.put(b, map.getOrDefault(b, 0) - 1);
            if (tot == 0) ans++;
        }
        return ans;
    }
}
  • 1.
  • 2.
  • 3.
  • 4.
  • 5.
  • 6.
  • 7.
  • 8.
  • 9.
  • 10.
  • 11.
  • 12.
  • 13.
  • 14.
  • 15.
  • 16.
  • 17.
  • 18.
  • 19.

Python 代码：

class Solution:
    def maxChunksToSorted(self, arr: List[int]) -> int:
        clone = sorted(arr)
        n, ans, tot = len(arr), 0, 0
        mapping = defaultdict(int)
        for i in range(n):
            a, b = arr[i], clone[i]
            if mapping.get(a, 0) == -1:
                tot -= 1
            elif mapping.get(a, 0) == 0:
                tot += 1
            mapping[a] = mapping.get(a, 0) + 1
            if mapping.get(b, 0) == 1:
                tot -= 1
            elif mapping.get(b, 0) == 0:
                tot += 1
            mapping[b] = mapping.get(b, 0) - 1
            if tot == 0:
                ans += 1
        return ans
  • 1.
  • 2.
  • 3.
  • 4.
  • 5.
  • 6.
  • 7.
  • 8.
  • 9.
  • 10.
  • 11.
  • 12.
  • 13.
  • 14.
  • 15.
  • 16.
  • 17.
  • 18.
  • 19.
  • 20.

TypeScript 代码：

function maxChunksToSorted(arr: number[]): number {
    let clone = [...arr].sort((a,b)=>a-b)
    let n = arr.length, ans = 0
    const map = new Map<number, number>()
    for (let i = 0, tot = 0; i < n; i++) {
        const a = arr[i], b = clone[i]
        if (!map.has(a)) map.set(a, 0)
        if (map.get(a) == 0) tot++
        else if (map.get(a) == -1) tot--;
        map.set(a, map.get(a) + 1)
        if (!map.has(b)) map.set(b, 0)
        if (map.get(b) == 0) tot++
        else if (map.get(b) == 1) tot--
        map.set(b, map.get(b) - 1)
        if (tot == 0) ans++
    }
    return ans
};
  • 1.
  • 2.
  • 3.
  • 4.
  • 5.
  • 6.
  • 7.
  • 8.
  • 9.
  • 10.
  • 11.
  • 12.
  • 13.
  • 14.
  • 15.
  • 16.
  • 17.
  • 18.
  • 时间复杂度：完美世界，最大规模裁员_数组_26
  • 空间复杂度：完美世界，最大规模裁员_后端_25