leetcode 995. K 连续位的最小翻转次数 (区间更新,单点查询)

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

来源:力扣(LeetCode)
链接:https://leetcode-cn.com/problems/minimum-number-of-k-consecutive-bit-flips
著作权归领扣网络所有。商业转载请联系官方授权,非商业转载请注明出处。

思路:对于这种翻转某个区间的问题,很容易想到是贪心,因为在边界的点被反转多次是无意义的,所以我们考虑从左往右扫描,(从右往左也是可行的),对于每个点,我们考虑他当前的状态(可能是被翻转过多次的),如果状态是1,那么就continue,否则我们就要从这个点开始翻转,当前i+K > N(即剩余的长度小于K)则return -1(无法完成翻转).
如果可以就翻转这个区间。如果是直接暴力翻转 时间复杂度就是O(N^2)了,铁定超时,不过其他语言似乎能通过,应该是给的时间太多了,不过直接暴力不是一种好的做法。

现在问题被转化为区间翻转,单点查询的一个问题了。

第一种做法,利用树状数组

  • 时间复杂度 O(NlogN)
  • 空间复杂度 O(N)

代码如下:

class Solution {
public:
    int dat[30010];
    int N;
    void add(int l,int v){
        while(l <= N){
            dat[l] += v;
            l += (l&-l);
        }
    }
    int query(int p){
        int s = 0;
        while(p > 0){
            s += dat[p];
            p -= (p&-p);
        }
        return s;
    }
    int minKBitFlips(vector<int>& A, int K) {
        
        N = A.size();
        memset(dat,0,sizeof(dat));
        int res = 0;
        for(int i=0;i<N;++i){
            int value = query(i+1);
            if(A[i] == 0){
                if(value % 2 == 1)  continue;
                else{
                    if(i+K > N) return -1;
            //        printf("i = %d,l = %d,r = %d\n",i,i+1,i+1+K);
                    add(i+1,1);
                    add(i+1+K,-1);
                    res++;
                }
            }
            else{
                if(value % 2 == 0)  continue;
                else{
                    if(i+K > N) return -1;
           //         printf("i = %d,l = %d,r = %d\n",i,i+1,i+1+K);
                    add(i+1,1);
                    add(i+1+K,-1);
                    res++;
                }
            }
        }
        return res;
    }
};

如果不理解树状数组这种数据结构可以看这里。
https://blog.csdn.net/zhao5502169/article/details/75666740

第二种做法,利用标记维护区间

– 时间复杂度O(N)
– 空间复杂度O(N)
这一种做法更好,我第一时间也没想到。看了下官方题解,才想起来,自己之前也做过类似的这种题目。因为查询总是在更新后面的,所以我们可以用一个变量记录到当前点发生了多少次翻转。每次翻转区间在左边打一个正的标记,右边打一个负的标记,即可。
代码如下:

class Solution {
public:
    int minKBitFlips(vector<int>& A, int K) {
        int N = A.size();
        vector<int> f(N+10,0);//记得要初始化
        int now = 0;//用于记录当前点被翻转多少次
        int res = 0;
        for(int i=0;i<N;++i){
            now += f[i];//加上当前点的标记值。
            if((A[i]+now)%2 == 1)
                continue;
            else{
                if(i+K > N) return -1;
                else{
                    res++;
                    now++;//因为当前点就是左边界,所以直接++,就相当于是左标记被读取
                    f[i+K] = -1;
                }
            }
        }
        return res;
    }
};

https://blog.csdn.net/zhao5502169/article/details/81213508
这里面是我之前写的,和这个题相似的题目,做法是相同的,利用第二种做法。

©️2020 CSDN 皮肤主题: 编程工作室 设计师:CSDN官方博客 返回首页