[Swift]LeetCode775. 全局倒置与局部倒置 | Global and Local Inversions

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

We have some permutation Aof [0, 1, ..., N - 1], where N is the length of A.

The number of (global) inversions is the number of i < j with 0 <= i < j < N and A[i] > A[j].

The number of local inversions is the number of i with 0 <= i < N and A[i] > A[i+1].

Return true if and only if the number of global inversions is equal to the number of local inversions.

Example 1:

Input: A = [1,0,2]
Output: true
Explanation: There is 1 global inversion, and 1 local inversion.

Example 2:

Input: A = [1,2,0]
Output: false
Explanation: There are 2 global inversions, and 1 local inversion.

Note:

• A will be a permutation of [0, 1, ..., A.length - 1].
• A will have length in range [1, 5000].
• The time limit for this problem has been reduced.

---

数组 A 是 [0, 1, ..., N - 1] 的一种排列，N 是数组 A 的长度。全局倒置指的是 i,j 满足 0 <= i < j < N 并且 A[i] > A[j] ，局部倒置指的是 i 满足 0 <= i < N 并且 A[i] > A[i+1] 。

当数组 A 中全局倒置的数量等于局部倒置的数量时，返回 true 。 

示例 1:

输入: A = [1,0,2]
输出: true
解释: 有 1 个全局倒置，和 1 个局部倒置。

示例 2:

输入: A = [1,2,0]
输出: false
解释: 有 2 个全局倒置，和 1 个局部倒置。

注意:

• A 是 [0, 1, ..., A.length - 1] 的一种排列
• A 的长度在 [1, 5000]之间
• 这个问题的时间限制已经减少了。

---

Runtime: 380 ms

Memory Usage: 19.1 MB

class Solution {
    func isIdealPermutation(_ A: [Int]) -> Bool {
        for i in 0..<A.count
        {
            if abs(A[i] - i) > 1
            {
                return false
            }
        }
        return true
    }
}

---

476ms

class Solution {
    func isIdealPermutation(_ A: [Int]) -> Bool {
        var leftMax = Int.min
        for i in 0..<A.count - 1 {
            if A[i] > A[i + 1] && leftMax > A[i + 1] {
                return false
            }
            leftMax = max(leftMax, A[i])
        }
        var rightMin = Int.max
        for i in (1..<A.count).reversed() {
            if A[i - 1] > A[i] && rightMin < A[i - 1] {
                return false
            }
            rightMin = min(rightMin, A[i])
        }
        return true
    }
}

---

656ms

class Solution {
    func merge_sort(_ array: inout[Int], _ global: inout Int, _ local: inout Int, _ start: Int, _ end: Int) {
        //print("[(start), (end))")
        guard end - start > 1 else { return }
        let mid = (start + end) / 2
        if mid - 1 >= start {
            local += array[mid - 1] > array[mid] ? 1 : 0
        }
        merge_sort(&array, &global, &local, start, mid)
        merge_sort(&array, &global, &local, mid, end)
        
        let copy = Array(array[start..<mid])
        var i = copy.startIndex, j = mid, k = start
        while i < copy.endIndex {
            if j >= end || copy[i] <= array[j] { 
                array[k] = copy[i]
                i += 1
            } else {
                array[k] = array[j]
                j += 1
                global += copy.endIndex - i
            }
            k += 1
        }
    }
    func isIdealPermutation(_ A: [Int]) -> Bool {
        var global = 0, local = 0
        var array = A
        merge_sort(&array, &global, &local, 0, array.count)
        return global == local
    }
}

---

8688ms

class Solution {
    func isIdealPermutation(_ A: [Int]) -> Bool {
        for i in 0..<A.count-1 {
            var k = i - 1
            if A[i] <= A[i+1] {
                while k >= 0 {
                    if A[k] > A[i+1] { return false }
                    k -= 1
                }
            }
            else {
                while k >= 0 {
                    if A[k] >= A[i] { return false }
                    if A[k] < A[i] && A[k] > A[i+1] { return false }
                    k -= 1
                }
            }
        }
        return true
    }
}