995. Minimum Number of K Consecutive Bit Flips（K 连续位的最小翻转次数）解法（C++ & 注释）

1. 题目描述

在仅包含 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 <= A.length <= 30000
• 1 <= K <= A.length

题目链接：中文题目；英文题目

2. 贪心（Greedy）

2.1 解题思路

题目要求把所有的0变成1，那么一个比较直接的思路就是：遍历整个数组，遇到0（序号i），则把nums[i] ~ nums[i + K - 1]全部反转，计数（count）加一，这样我们保证nums[i]一定为1，那么我们继续从i + 1开始向后检查；如果遇到0，但i + K -1 >= 数组长度（len）那么表示当前没有足够的数进翻转，所以没办法把所有的0变成1，返回-1即可。下面举两个例子进行说明：

[1,0,1,0], k = 2

i = 1时进行翻转，[1,0,1,0] -> [1,1,0,0]，当i = 2时又翻转，[1,1,0,0] -> [1,1,1,1]，后面全部都是1，所以返回2即可。

[0,0,1,0], k = 2

i = 0翻转，[0,0,1,0] -> [1,1,1,0]，当i = 3时，i + k - 1 >= 3，后面没有足够的数进行翻转，所以返回-1；

这种思路有一个不足的地方，就是我们需要向后翻转数字，再回到i + 1的位置，这样会浪费一定的时间。从上面的例子我们可以发现：

当翻转nums[i] ~ nums[i - K - 1]后，如果num[i + 1] ~ nums[i + K - > 1]有0才需要再一次翻转，否则是不需要翻转的，换个角度，如果我们不变换原数组，那么最开始是遇到0需要翻转，翻转之后，需要遇到1才需要翻转。

举个例子来说明：

[1,0,1,0], k = 2

第一次翻转后：[1,1,0,1]，下一次翻转的位置是i = 2，翻转后是0，原数组是1；反过来，如果翻转后是1，那原数组就是0。根据这个特点，我们就不用真的去翻转数字，可以初始化一个flip去记录下一个需要翻转的数。只是这样有一个问题需要解决：当抵达nums[i + K]，需要将flip重置会原来的状态，所以初始化一个hints数组，如果i需要翻转，那么hints[i + K]则标记为1，表示边界位置，每次检查hints，如果为1，则重置flip。

这里我们使用异或运算进行标记：0 ^ 0 = 0, 0 ^ 1 = 1，所以^ 1表示重置状态。此部分对应代码：2.2.1 使用额外空间。

另外，我们可以不使用额外空间，直接在原数组进行标记。通过上面的讲解，我们可以知道翻转的数字是0或者1，也可以称之为偶数和奇数，所以同样初始化一个flip = 0，当nums[i] % 2 == flip，表示对应需要翻转的数， 则nums[i] += 2，flip++。对于边界的标记，需要向前标记：检查nums[i - K] > 1，如果为真，表示i为边界，nums[i - K] -= 2, flip减一。总之，和上面的方法相比，对flip加减相当于 flip ^= 1和flip ^= hints[i]，nums[i] % 2 == flip相当于A[i] == flip。此部分对应代码：2.2.2 无需使用额外空间。

最后举一个例子再说明一下：

[1,0,0,1], k = 2

1. 初始化flip = 0；
2. i = 1，flip % 2 = 0 == 0，则[1,0,0,1] -> [1, 2, 0, 1]，flip = 1；
3. i = 2，flip % 2 = 1 != 0；
4. i = 3，nums[i - k] > 1，nums[i - k] -= 2, 则[1, 2, 0, 1] -> [1, 0, 0, 1]，flip = 0，flip % 2 = 0 != 1，返回1即可。

2.2 实例代码

2.2.1 使用额外空间

class Solution {
public:
    int minKBitFlips(vector<int>& A, int K) {
        int len = A.size(), ans = 0, flip = 0;
        vector<int> hints(len, 0);

        for (int i = 0; i < len; i++) {
            flip ^= hints[i]; // 检查是否到达某个子串的边界
            if (A[i] == flip) {
                ans++;
                if (i + K > len) return -1;
                flip ^= 1; // 下一个需要翻转的数字： 0 -> 1， 1 -> 0
                if (i + K < len) hints[i + K] ^= 1; // 标记边界
            }
        }

        return ans;
    }
};

2.2.2 无需使用额外空间

class Solution {
public:
    int minKBitFlips(vector<int>& A, int K) {
        int len = A.size(), ans = 0, flip = 0;

        for (int i = 0; i < len; i++) {
            if (i >= K && A[i - K] > 1) { flip--; A[i - K] -= 2; } // 检查是否到达某个子串的边界
            if (flip % 2 == A[i]) {
                if (i + K > len) return -1;
                A[i] += 2; // 标记边界
                flip++;
                ans++;
            }
        }

        return ans;
    }
};

3. 参考资料

1. 995. Minimum Number of K Consecutive Bit Flips
2. [Java/C++/Python] One Pass and O(1) Space

---