LeetCode 1004-最大连续1的个数III

前言

对于数组 $A$ 的区间 $[left,right]$ 而言，只要它包含不超过 $k$ 个 $0$，我们就可以根据它构造出一段满足要求，并且长度为 $right-left+1$ 的区间。

因此，我们可以将该问题进行如下转化，即：对于任意的右端点 $right$，希望找到最小的左端点 $left$，使得 $[left,right]$ 包含不超过 $k$ 个 $0$。只要我们枚举所有可能的右端点，取最大区间长度即可得到答案。

要想快速判断一个区间内 $0$ 的个数，我们可以考虑将数组 $A$ 中的 $0$ 变成 $1$，$1$ 变成 $0$。此时，我们对数组 $A$ 求出前缀和，记为数组 $P$，那么 $[left,right]$ 中包含不超过 $k$ 个 $1$（注意这里就不是 $0$ 了），当且仅当二者的前缀和之差：$P[right]-P[left-1]\le k$。

方法一：二分查找

思路与算法：$$P[right]-P[left-1]\le k==P[left-1]\ge P[right]-k\text{\hspace{1em}(1)}$$

也就是说，我们需要找到满足（1）式的最小 $left$。由于数组 $A$ 中仅包含 $0/1$，因此前缀和数组是一个单调递增的数组，我们就可以使用二分查找的方法得到 $left$。

细节
注意到（1）式的左侧下标是 $left-1$ 而不是 $left$，那么我们在构造前缀和数组时，可以将前缀和整体向右移动一位，空出 $P[0]$ 的位置，即：$$\{\begin{array}{l}P[0]=0\\ P[i]=P[i-1]+(1-A[i-1])\end{array}$$此时，我们在数组 $P$ 上二分查找到的下标即为 $left$ 本身，同时我们也避免了原先 $left=0$ 时 $left-1=-1$ 不在数组合法的下标范围中的边界情况。
代码：

class Solution {
public:
    int longestOnes(vector<int>& nums, int k) {
        int n = nums.size();
        vector<int> P(n + 1);                       //前缀和数组
        for(int i = 1; i <= n; ++i){                //构造前缀和数组，将原数组中01互换再求前缀和
            P[i] = P[i - 1] + (1 - nums[i - 1]);
        }
        int ans = 0;
        for(int right = 0; right < n; ++right){
            //lower_bound返回大于等于P[right + 1] - k的第一个元素的迭代器位置（二分查找）
            int left = lower_bound(P.begin(), P.end(), P[right + 1] - k) - P.begin();
            ans = max(ans, right - left + 1);
        }
        return ans;
    }
};

复杂度分析：

• 时间复杂度：$O(n\log n)$，其中 $n$ 是数组 $A$ 的长度。
• 空间复杂度：$O(n)$

方法二：滑动窗口

我们继续观察（1）式，由于前缀和数组 $P$ 是单调递增的，那么（1）式的右侧 $P[right]-k$ 同样也是单调递增的。因此，我们可以发现：随着 right 的增大，满足（1）式的最小的 $left$ 是单增的。

这样一来，我们就可以使用滑动窗口来实时地维护 $left$ 和 $right$ 了。在 $right$ 向右移动的过程中，我们同步移动 $left$，直到 $left$ 为最小的满足（1）式的位置，此时我们就可以使用此区间对答案进行更新了。

细节
当我们使用滑动窗口代替二分查找解决本题时，就不需要显式地计算并保存出前缀和数组了。我们只需要知道 $left$ 和 $right$ 作为下标在前缀和数组中对应的值，因此我们只需要用两个变量 $lsum$ 和 $rsum$ 记录 $left$ 和 $right$ 分别对应的前缀和即可。
代码

class Solution {
public:
    int longestOnes(vector<int>& nums, int k) {
        int n = nums.size();
        int left = 0, lsum = 0, rsum = 0;
        int ans = 0;
        for(int right = 0; right < n; ++right){
            rsum += 1 - nums[right];                    //计算right对应的前缀和
            while(lsum < rsum - k){                     //滑动窗口实时维护
                lsum += 1 - nums[left];                 //计算left对应的前缀和
                ++left;
            }
            ans = max(ans, right - left + 1);
        }
        return ans;
    }
};

复杂度分析

• 时间复杂度：$O(n)$
• 空间复杂度：$O(1)$

方法三：维护一个单调变长的窗口

思路

• l 是窗口左端点，负责移动起始位置，r 是窗口右终点，负责扩展窗口。
• k 是资源数，每次右扩替换 $0$ 占用 1 个；左扩且当前元素为 $0$ 时释放 1 个。
• 至于为什么 r-l 就是答案，看两个判断：r 每次循环都加 1，l 只有 k<0 才加 1，这样 r-l 只会递增，最多也就保持不变。

代码

class Solution {
public:
    int longestOnes(vector<int>& nums, int k) {
        int l = 0, r = 0;
        while(r < nums.size()){
            if(nums[r++] == 0)
                k--;
            if(k < 0 && nums[l++] == 0)
                k++;
        }
        return r - l;
    }
};