[leetcode每日一题2021/2/18]【详解】995. K 连续位的最小翻转次数

题目来源于leetcode，解法和思路仅代表个人观点。传送门。
难度：困难
时间：2h-

题目

在仅包含 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

思路&代码

贪心翻转

这里有点贪心的味道。

思考这个case

[1,1,1,0,x,x,x,...]
3

要使的翻转次数最少，实际上只需要翻转不多余就行了

[1,1,1,1,0,x,x,x,...]
         ↑   ↑
       left right

left指针指向0，left指针左边全部都是1，一定是翻转left指针右边的一段，才能使得总的翻转次数最少。

为什么呢？思考反例，

[1,1,1,1,0,x,x,x,...]   =>   [1,1,0,0,1,x,x,x,...]  =>  [0,0,1,0,1,x,x,x,...] 
     ↑   ↑                    ↑   ↑
   right left              right  left

如果翻转left指针右边这一段，就会使得出现没有必要的翻转，这个翻转导致把之前已经翻转好的数组给打乱了。

---

假设A[0~left)=1，那么只需要考虑A[left,n)长度的数组即可，相当于输入规模下降了。

那么我们每次贪心地选择从左到右的第一个0进行翻转。确保left指针左边的元素全为1，当left指针指向n的时候，我们就已经翻转完了所有元素。

特别地，因为一次翻转，需要翻转[left,left+K)长度的元素。如果某次翻转left+K > n，那么此次翻转失败，整个数组不可能全部翻转为1，return -1。

class Solution {
public:
    void flip(vector<int>& A,int left,int right){
        for(int i=left;i<=right;i++){
            if(A[i] == 0){
                A[i] = 1;
            }else{
                A[i] = 0;
            }
        }
    }
    int minKBitFlips(vector<int>& A, int K) {
        int left = 0;
        int right = left + K -1;
        //数组长度
        int n = A.size();
        int ans = 0;
        /*
        * 找到第一个为0的位置，反转k位，果然超时
        * 时间复杂度为O(nk)，空间复杂度为O(1)
        */
        for(int i=0;i<n;i++){
            if(A[i] == 1){
                continue;
            }
            if(i+K-1 >= n){
                return -1;
            }
            flip(A,i,i+K-1);
            ans++;
        }
        return ans;
    }
};

时间复杂度： O(nK)。n为数组长度。K为翻转一次的长度。
空间复杂度： O(1)。

提交,超时了。很显然，leetcode困难题没有这么容易给过。

---

翻转优化

优化的思路

优化一下。
超时优化有两种思路。

1. 沿着刚才的思路，看着时间复杂度继续优化。
2. 换个思路再做一次。

我这里觉得刚才那个贪心思路很不错，所以打算继续往下优化。

---

时间复杂度的考虑

首先观察时间复杂度：O(nk)，接近n²，其实也不是很慢，如果继续往下的话就是O(nlogn)和O(n)，因为肯定需要遍历完数组中的所有元素，时间复杂度不可能小于O(n)。

考虑O(nlogn)，熟悉的算法有二分，排序等。
这里排序没有用，二分也没有用。

考虑O(n)，那么我们只能遍历一次数组。

我这里觉得大概率是O(n)的算法，所以接着往下思考。

---

空间换时间的考虑

一般来说，想要时间复杂度更低，那就用空间换时间。而且，刚才超时的算法，空间复杂度是O(1)，那就很大可能是空间换时间优化的方向。

具体地考虑

上面的考虑，只能提供一个大概的方向，想要做出来，还是需要具体问题具体分析。

到底算法慢在哪？
我们每次都会找到第一个0，对元素A[left]会翻转[left,left+K)长度的区间，但是实际上，翻转数组并不需要执行，我们只需要翻转我们需要找的目标即可。即，这次找0，下次找1，下次找0。

---

下面的例子已经翻转了两次。第一次翻转[left,right]，第二次翻转[next_left,next_right]。

K=4, right = left+K-1
     next_left next_right        next_left next_right         next_left next_right
           ↓     ↓                     ↓     ↓                      ↓     ↓
[...,1,0,0,1,1,1,1,...]  => [...,1,1,1,0,0,1,1,...]  =   [...,1,1,1,1,1,0,0,...]
       ↑     ↑                     ↑     ↑                      ↑     ↑
      left  right                left  right                  left  right

该例子中，如何寻找目标？

1. 找到第一个0，翻转
2. 在[left,right]之间找1，在(right,n)之间找0，翻转
3. 在[next_left,right]之间找0，在(right,next_right]之间找1，在(next_right,n)之间找0，翻转

如上例子分析后，可以发现，我们寻找的目标每次翻转的时候，都是在上一次翻转的分界线处。

---

这样，我们可以定义一个翻转分界线的数组flipFlag，记录每次翻转的right分界线。每次遍历的指针到达分界线处时，我们就翻转我们寻找的目标。

class Solution {
public:
    int minKBitFlips(vector<int>& A, int K) {
        int left = 0;
        int right = left + K -1;
        //数组长度
        int n = A.size();
        int ans = 0;
        /*
        * 虚拟反转，空间换时间
        * 使用标记数组，指针碰上标记数组后，寻找的数flag，翻转
        * 时间复杂度为O(n)，空间复杂度为O(n)
        */
        //0表示不翻转，1表示翻转
        vector<int> flipFlags(n,0);
        //下一个寻找的数
        int flag = 1;
        for(int i=0;i<n;i++){
            if(flipFlags[i] == 1){
                //翻转flag
                flag = flag==0?1:0;
            }
            //跳过无用的
            if(A[i]==flag){
                continue;
            }
            //右边界
            right = i + K;
            //如果当前需要翻转的区间 大于 数组了 说明一定不能完成翻转
            if(right > n){
                return -1;
            }
            //翻转一次
            flag = flag==0?1:0;
            //记录翻转次数
            ans++;
            //使用if防止越界,因为right是可以到n的
            if(right < n){
                //标记下一次flag需要翻转的位置
                flipFlags[right] = 1;
            }
        }
        return ans;
    }
};

时间复杂度： O(n)，n为数组大小。
空间复杂度： O(n)，n为数组大小。

---

空间优化

其实时间复杂度到达O(n)，已经差不多了，我就没有继续优化了。
看了官方的题解，空间复杂度还可以优化到O(1)。

---

因为我们A存放的数，只有0和1，我们可以原地修改A数组，用其他值表示【目标翻转的分界线】，代替flipFlag数组的使用。

class Solution {
public:
    int minKBitFlips(vector<int>& A, int K) {
        int left = 0;
        int right = left + K -1;
        //数组长度
        int n = A.size();
        int ans = 0;
		/*
        * 参考官方答案，优化空间到O(1)
        */
        for(int i=0;i<n;i++){
//---------------------------------------------
            if(A[i] == 2 || A[i] == 3){
                //复原flag
                A[i] -= 2;
//----------------------------------------------
                //翻转flag
                flag ^= 1;
            }
            //跳过无用的
            if(A[i]==flag){
                continue;
            }
            //右边界
            right = i + K;
            //如果当前需要翻转的区间 大于 数组了 说明一定不能完成翻转
            if(right > n){
                return -1;
            }
            //翻转一次
            flag ^= 1;
            //记录翻转次数
            ans++;
            //使用if防止越界,因为right是可以到n的
            if(right < n){
//-----------------------------------------------
                //标记下一次flag需要翻转的位置
                A[right] +=2;
//-----------------------------------------------
            }
        }
        return ans;
    }
};

时间复杂度： O(n)。n为数组A的大小。
空间复杂度： O(1)。

PS:
对比一下空间O(n)和O(1)的提交，怎么感觉没什么区别。