995. K 连续位的最小翻转次数

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

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

输入：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]

我的代码 100ms

class Solution {
public:
    int minKBitFlips(vector<int>& A, int K) {
        int len = A.size();
        vector<int> array(len,0);
        int res = 0,flip = 0;
        for(int i = 0;i < len;i++) {
            flip =(flip+array[i])%2;
            if(flip)
                A[i]=1-A[i];
            if(A[i] == 0) {
                if(i + K > len) return -1;
                res++;
                flip = 1+flip;
                if(i+K < len) array[i+K] +=1;   
            }   
        }
        return res;
    }
};

另一版本 196ms

class Solution {
public:
    int time=0;
    list<int> lis;
    int total=0;
    int calculate(vector<int> &A,int m)
    {
        int time=0;
        while(!lis.empty()&&lis.front()<m)
        {
            lis.pop_front();
        }
        time=lis.size()+total;
        time%=2;
        if(time==1)
            return 1-A[m];
        else
            return A[m];
        
    }
    void dfs(vector<int> &A, int &K,int m)
    {
        if(A.size()-m==K)
        {
            int number0=0;
            int temp;
            for(int i=m;i<A.size();i++)
            {
                A[i]=calculate(A,i);
                if(i==m)
                {
                    temp=A[i];
                }
                if(A[i]!=temp)
                {
                    time=-1;
                    return;
                }
            }
            if(temp==1) return;
            else
            {
                time++;
                return;
            }
        }
        A[m]=calculate(A,m);
        if(A[m]==0)
        {
            if(m+K-1>=A.size()-1) total++;
            else
                lis.push_back(m+K-1);
            time++;
        }
        dfs(A, K,m+1);
    }
    int minKBitFlips(vector<int>& A, int K) {
        dfs(A, K,0);
        return time;
        
    }
};