【算法&面试】贪心算法 力扣 995. K 连续位的最小翻转次数

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

来源：力扣（LeetCode）

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

我和大佬的解

下面的是我写的暴力求解（我自己以为自己很贪心，直接前后分别来一个索引开始往中间改变，正儿八经的改变数组中的值）。

上面的是时间超过100%的解，太贪了吧。有n个元素，就只遍历了n次。。。。。还不带改变数组元素的。

我就开始分析这位帅比的代码，嗯，刚开始对我来说有点难度，4点钟起床刚到7点，边睡边搞花了半个小时终于想通了。这道题非贪心和贪心的差距太大了，比我之前做的所有贪心算法题都大！所以准备记录一下，分析分析，深度思考一下，如果在看的朋友对这道题有比我更好的想法，可以在评论区相互交流一下。

我的代码（丑陋、边写边改，有一个思路就直接开写了，没有设计，但是没办法，我才刚开始学习，做题套路还需刻意练习一下）

一定不要看我的代码！！！！对你没有任何好处！！！

public static int minKBitFlips(int[] A, int K) {
    int start = 0;
    int end = A.length - 1;
    int daan = 0;
    boolean p = false;
    if (A.length != K) {
        while (start < A.length - K && start < end && end >= K) {
            while (end > start && start < A.length - K && A[start] == 1) {
                start++;
            }
            int now = A[start];
            for (int i = start; i < K + start && now == 0; i++) {
                A[i] = A[i] ^ 1;
                p = true;
            }
            if (p) {
                daan++;
                p = false;
            }
            while (end > start && end > K - 1 && A[end] == 1) {
                end--;
            }
            now = A[end];
            for (int i = end; i > end - K && now == 0; i--) {
                A[i] = A[i] ^ 1;
                p = true;
            }
            if (A[start] == 0) {
                return -1;
            }
            if (p) {
                daan++;
                p = false;
            }
        }
    } else {
        int q = A[0];
        for (int i1 : A) {
            if (q != i1) {
                return -1;
            }
        }
        return A[0] == 1 ? 0 : 1;
    }

    for (int i1 : A) {
        if (i1 == 0) {
            return -1;
        }
    }
    return daan;
}

别人的代码

单向遍历，直接开干，如果最后几个还有不合规的，则直接返回-1。

• flipped 是用于记录当前位置对应的错误的值。第一位为0。
  • 这个元素在i>=K的时候一直在改变flipped ^= isFlipped[i - K];，isFlipped 存储的是当前这个位置是否是开始翻转的起始位置。如果是则isFlipped[now] = 1 那么 flipped ^= 1; 的操作就为翻转flipped的值（0变1，1变0）。
• if (A[i] == flipped) 上面说过，flipped是记录的当前应该为的错误的值。所以A[i] == flipped表示，当翻转后 A[i] 这个位置对应的值为0时（没有改变数组元素，只是换了一种方式表示该值为0），1. 记录需要翻转一次 、2. 记录 i 这个位置需要开始翻转、3. flipped翻转。

public static int minKBitFlips(int[] A, int K) {
    int n = A.length;
    //开始翻转的位置的下标对应的值为1。
    int[] isFlipped = new int[n];
    int ans = 0;
    //flipped记录的是当前这个位置i不合规的值。
    int flipped = 0;

    for (int i = 0; i < n; i++) {
        if (i >= K) {
            //当前位置，当前被改为了flipped
            //如果超过改变的初始位置，则置为0，继续操作
            flipped ^= isFlipped[i - K];
        }
		//如果当前A[i]等于不合规的值，则就开始翻转
        if (A[i] == flipped) {
            //如果最后K-1个元素，还有不合规的，则直接返回-1，因为无法完成正常翻转
            if (i + K > n) {
                return -1;// 如果没办法翻转整个子数组了，那么就不可行
            }
            //翻转一次，返回值++
            ans++;
            //当前位置开始翻转
            isFlipped[i] = 1;
            //flipped翻转
            flipped ^= 1;
        }
    }
    return ans;
}