[Swift]LeetCode995. K 连续位的最小翻转次数 | Minimum Number of K Consecutive Bit Flips

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

In an array A containing only 0s and 1s, a K-bit flip consists of choosing a (contiguous) subarray of length K and simultaneously changing every 0 in the subarray to 1, and every 1 in the subarray to 0.

Return the minimum number of K-bit flips required so that there is no 0 in the array.  If it is not possible, return -1.

Example 1:

Input: A = [0,1,0], K = 1
Output: 2
Explanation: Flip A[0], then flip A[2].

Example 2:

Input: A = [1,1,0], K = 2
Output: -1
Explanation: No matter how we flip subarrays of size 2, we can't make the array become [1,1,1].

Example 3:

Input: A = [0,0,0,1,0,1,1,0], K = 3
Output: 3
Explanation:
Flip A[0],A[1],A[2]: A becomes [1,1,1,1,0,1,1,0]
Flip A[4],A[5],A[6]: A becomes [1,1,1,1,1,0,0,0]
Flip A[5],A[6],A[7]: A becomes [1,1,1,1,1,1,1,1] 

Note:

1. 1 <= A.length <= 30000
2. 1 <= K <= A.length

---

在仅包含 0 和 1 的数组 A 中，一次 K 位翻转包括选择一个长度为 K的（连续）子数组，同时将子数组中的每个 0 更改为 1，而每个 1 更改为 0。

返回所需的 K 位翻转的次数，以便数组没有值为 0 的元素。如果不可能，返回 -1。 

示例 1：

输入：A = [0,1,0], K = 1
输出：2
解释：先翻转 A[0]，然后翻转 A[2]。

示例 2：

输入：A = [1,1,0], K = 2
输出：-1
解释：无论我们怎样翻转大小为 2 的子数组，我们都不能使数组变为 [1,1,1]。

示例 3：

输入：A = [0,0,0,1,0,1,1,0], K = 3
输出：3
解释：
翻转 A[0],A[1],A[2]: A变成 [1,1,1,1,0,1,1,0]
翻转 A[4],A[5],A[6]: A变成 [1,1,1,1,1,0,0,0]
翻转 A[5],A[6],A[7]: A变成 [1,1,1,1,1,1,1,1] 

提示：

1. 1 <= A.length <= 30000
2. 1 <= K <= A.length

---

Runtime: 632 ms

Memory Usage: 19 MB

class Solution {
    func minKBitFlips(_ A: [Int], _ K: Int) -> Int {
        var ans:Int = 0
        var n:Int = A.count
        var f:[Bool] = [Bool](repeating:false,count:n + 1)
        var sum:Bool = false
        for i in 0..<n
        {
            //异或
            sum = (sum == f[i]) ? false : true
            if sum == (A[i] == 1)
            {
                if i + K > n {return -1}
                f[i + K] = !f[i + K]
                sum = !sum
                ans += 1
            }
        }
        return ans        
    }
}

---

744ms 

class Solution {
    func minKBitFlips(_ A: [Int], _ K: Int) -> Int {
        var left = 0
        var flips = 0
        var totalFlips = 0
        var a = A
        
        while left < a.count {
            totalFlips = left < K ? totalFlips : totalFlips - a[left - K ]
        
            if totalFlips % 2 == 0 && a[left] == 0 {
                if left > a.count - K {
                    return -1
                }
                flips += 1
                totalFlips += 1
                a[left] = 1
            } else if totalFlips % 2 == 1 && a[left] == 1 {
                if left > a.count - K {
                    return -1
                }
                
                flips += 1
                totalFlips += 1
                a[left] = 1
            } else {
                a[left] = 0
            }
            
            left += 1
        }
        
        return flips
    }
}

---

748ms

class Solution {
    func minKBitFlips(_ A: [Int], _ K: Int) -> Int {
        var A = A
        var count = 0
        var i = 0
        var flipHint = A.map { _ in false }
        var flipped = false
        while i < A.count {
            if flipHint[i] == true {
                flipped.toggle()
            }

            if A[i] == (flipped ? 1 : 0) {
                flipped.toggle()
                if i + K < A.count {
                    flipHint[i+K] = true
                } else if i + K > A.count {
                    return -1
                }
                count += 1
            }
            i += 1
        }
        return count
    }
}

---

900ms

class Solution {
    func minKBitFlips(_ A: [Int], _ K: Int) -> Int {
        var count = 0, firstIndex = 0, A = A
        var lastFlip: [Int] = []

        while firstIndex < A.count {
            defer { firstIndex += 1 }

            if let first = lastFlip.first,
                firstIndex >= first {
                lastFlip.removeFirst()
            }

            guard (A[firstIndex] + lastFlip.count) % 2 == 0 else {
                continue
            }
            if firstIndex + K > A.endIndex {
                return -1
            } else {
                lastFlip.append(firstIndex + K)
                count += 1
            }
        }

        return count
    }
}