[Swift]LeetCode768. 最多能完成排序的块 II | Max Chunks To Make Sorted II

★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★
➤微信公众号：山青咏芝（shanqingyongzhi）
➤博客园地址：山青咏芝（https://www.cnblogs.com/strengthen/）
➤GitHub地址：https://github.com/strengthen/LeetCode
➤原文地址： https://www.cnblogs.com/strengthen/p/10534904.html 
➤如果链接不是山青咏芝的博客园地址，则可能是爬取作者的文章。
➤原文已修改更新！强烈建议点击原文地址阅读！支持作者！支持原创！
★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★

This question is the same as "Max Chunks to Make Sorted" except the integers of the given array are not necessarily distinct, the input array could be up to length 2000, and the elements could be up to 10**8.

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?

Example 1:

Input: arr = [5,4,3,2,1]
Output: 1
Explanation:
Splitting into two or more chunks will not return the required result.
For example, splitting into [5, 4], [3, 2, 1] will result in [4, 5, 1, 2, 3], which isn't sorted.

Example 2:

Input: arr = [2,1,3,4,4]
Output: 4
Explanation:
We can split into two chunks, such as [2, 1], [3, 4, 4].
However, splitting into [2, 1], [3], [4], [4] is the highest number of chunks possible.

Note:

• arr will have length in range [1, 2000].
• arr[i] will be an integer in range [0, 10**8].

---

这个问题和“最多能完成排序的块”相似，但给定数组中的元素可以重复，输入数组最大长度为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]之间。

---

Runtime: 56 ms

Memory Usage: 19 MB

class Solution {
    func maxChunksToSorted(_ arr: [Int]) -> Int {
        var res:Int = 1
        var n:Int = arr.count
        var curMax:Int = Int.min
        var b:[Int] = arr
        for i in stride(from:n - 2,through:0,by:-1)
        {
            b[i] = min(arr[i], b[i + 1])
        }
        for i in 0..<(n - 1)
        {
            curMax = max(curMax, arr[i])
            if curMax <= b[i + 1]
            {
                res += 1            
            }
        }
        return res
    }
}

---

60ms

class Solution {
    func maxChunksToSorted(_ arr: [Int]) -> Int {
        var befores: [Int] = []
        var afters: [Int] = []
        var curMax = Int.min
        for num in arr {
            if num > curMax {
                curMax = num
            }
            befores.append(curMax)
        }
        var curMin = Int.max
        for num in arr.reversed() {
            if num < curMin {
                curMin = num
            }
            afters.append(curMin)
        }
        afters.reverse()
        var res = 0
        for i in 0..<arr.count-1 {
            if befores[i] <= afters[i+1] {
                res += 1
            }
        }
        return res + 1
    }
}

---

64ms

class Solution {
    func maxChunksToSorted(_ arr: [Int]) -> Int {
        guard arr.isEmpty == false else {
            return 0
        }
        let sortedArr = arr.sorted()
        let n = arr.count
        var res = 0
        var sum1 = 0
        var sum2 = 0
        for i in 0..<n {
            sum1 += arr[i]
            sum2 += sortedArr[i]
            if sum1 == sum2 {
                res += 1
                sum1 = 0
                sum2 = 0
            }
        }
        return res
    }
}

---

76ms

class Solution {
    func maxChunksToSorted(_ arr: [Int]) -> Int {
        let n = arr.count
        var minOfRight = Array(repeating: 0, count: n)
        var maxOfLeft = Array(repeating: 0, count: n)
        
        maxOfLeft[0] = arr[0]
        minOfRight[n-1] = arr[n-1]
        
        for i in 1..<n {
            maxOfLeft[i] = max(maxOfLeft[i-1], arr[i])
        }
        
        for i in (0..<(n - 1)).reversed() {
            minOfRight[i] = min(minOfRight[i+1], arr[i])
        }
        
        var res = 1
        
        for i in 1..<n {
            res += maxOfLeft[i-1] <= minOfRight[i] ? 1 : 0
        }
        
        return res
    }
}

---

Runtime: 80 ms

Memory Usage: 19.3 MB

class Solution {
    func maxChunksToSorted(_ arr: [Int]) -> Int {
        var nums = [Int : Int]()
        for item in arr {
            if let num = nums[item] {
                nums[item] = num + 1
            } else {
                nums[item] = 1
            }
        }
        
        var sum = 0
        let sortNums = nums.sorted { (dic1, dic2) -> Bool in
            return dic1.key < dic2.key
        }
        for item in sortNums {
            nums[item.key] = sum
            sum += item.value
        }
        
        let count = arr.count
        var left = 0
        var right = nums[arr[left]]!
        
        var preIndex = 0
        var result = 0

        while left < count {
            if arr[left] > arr[preIndex] {
                if let num = nums[arr[left]] {
                    preIndex = left
                    right = num
                }
            } else if arr[left] == arr[preIndex] {
                left += 1
            }
            
            while left <= right {
                if arr[left] == arr[preIndex] && left != preIndex && right < count - 1 {
                    right += 1
                } else if arr[left] > arr[preIndex] {
                    if let num = nums[arr[left]] {
                        preIndex = left
                        right = num
                    }
                }
                left += 1
            }
            result += 1
        }
        return result
    }
}

---

100ms

class Solution {
    func maxChunksToSorted(_ arr: [Int]) -> Int {
        var map = [Int: Int]()
        var sorted = arr.sorted()
        var nonZeroCount = 0
        var result = 0
        for i in 0..<sorted.count {
            let x = arr[i]
            let y = sorted[i]
            map[x] = (map[x] ?? 0) + 1
            if map[x] == 0 {
                nonZeroCount -= 1
            } else if map[x] == 1 {
                nonZeroCount += 1
            }
            map[y] = (map[y] ?? 0) - 1
            if map[y] == 0 {
                nonZeroCount -= 1
            } else if map[y] == -1 {
                nonZeroCount += 1
            }
            if nonZeroCount == 0 {
                result += 1
            }
        }
        return result
    }
}