力扣 995. K 连续位的最小翻转次数 模拟 差分 思维

https://leetcode-cn.com/problems/minimum-number-of-k-consecutive-bit-flips/

思路：想法很简单，从前往后遍历，如果某个位置不是$1$，就从这个位置开始向后翻转。但是如果暴力写的话，复杂度可能会达到$O(nk)$，喜提一发$TLE$，比如下面这份代码：

class Solution {
public:
    int minKBitFlips(vector<int>& A, int K) {
        int ans=0,n=A.size(),divid=n-K;
        for(int i=0;i<=divid;i++)
        {
            if(!A[i])
            {
                ++ans;
                for(int j=0;j<K;j++)
                    A[i+j]=!A[i+j];
            }
        }
        for(int i=divid+1;i<n;i++)
            if(!A[i])
                return -1;
        return ans;
    }
};

现在考虑怎么降低复杂度，事实上我们没必要模拟翻转的这个过程，只需要用一个变量记录当前位置所需要的翻转次数，然后进行判断即可。这样复杂度就变成$O(n)$了。

class Solution {
public:
    int minKBitFlips(vector<int>& A, int K) {
        int ans=0,n=A.size(),cnt=0;
        queue<int> q;
        for(int i=0;i<n;i++)
        {
            if(!q.empty()&&i==q.front())
            {
                --cnt;
                q.pop();
            }
            int tmp=cnt&1;
            if((tmp&&A[i])||(!tmp&&!A[i]))
            {
                if(i<=n-K)
                    ++cnt,++ans,q.push(i+K);
                else
                    return -1;
            }
        }
        return ans;
    }
};

也可以不用队列，用差分数组的思想，假设我们用数组$a$表示每个位置所需要的翻转次数，那么每次修改数组$a$的复杂度是$O(k)$的，但是如果我们维护差分数组$diff$，使得$dif{f}_i=a_i-a_{i-1}$，那么复杂度可以降低到$O(1)$，不过为了得到原来的$a_i$，我们需要计算${\sum }_{i=0}^{i=k}dif{f}_i$。

class Solution {
public:
    int minKBitFlips(vector<int>& A, int K) {
        int ans=0,n=A.size(),cnt=0;
        vector<int> diff(n+1);
        for(int i=0;i<n;i++)
        {
            cnt+=diff[i];
            if((cnt+A[i])%2==0)
            {
                if(i<=n-K)
                    ++cnt,++ans,--diff[i+K];
                else   
                    return -1;
            }
        }
        return ans;
    }
};

在原数组上动手脚的话，空间复杂度可以更低，不过懒得写了。