最大连续1的个数 III

给定一个由若干 $0$ 和 $1$ 组成的数组 $A$，我们最多可以将 $K$ 个值从 $0$ 变成 $1$ 。

返回仅包含 $1$ 的最长（连续）子数组的长度。

示例 1：

输入：A = [1,1,1,0,0,0,1,1,1,1,0], K = 2
输出：6
解释： 
[1,1,1,0,0,1,1,1,1,1,1]
粗体数字从 0 翻转到 1，最长的子数组长度为 6。

示例 2：

输入：A = [0,0,1,1,0,0,1,1,1,0,1,1,0,0,0,1,1,1,1], K = 3
输出：10
解释：
[0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,1,1,1,1]
粗体数字从 0 翻转到 1，最长的子数组长度为 10。

提示：

$$\begin{gathered} 1<=A.length<=20000 \\ 0<=K<=A.length \\ A[i]为0或1 \end{gathered}$$

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

因此，我们可以将该问题进行如下的转化，即：

对于任意的右端点 $\text{right}$，希望找到最小的左端点 $\text{left}$，使得 $[\text{left},\text{right}]$ 包含不超过 $K$ 个 $0$。

只要我们枚举所有可能的右端点，将得到的区间的长度取最大值，即可得到答案。

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

$$P[\text{right}]-P[\text{left}-1]$$

小于等于 $K$。这样一来，我们就可以容易地解决这个问题了。

1. 二分查找
   思路与算法
   $P[\text{right}]-P[\text{left}-1]\le K$
   等价于
   $P[\text{left}-1]\ge P[\text{right}]-K$ $(1)$
   也就是说，我们需要找到最小的满足 $(1)$ 式的 $\text{left}left$。由于数组 $A$ 中仅包含 $0/1$，因此前缀和数组是一个单调递增的数组，我们就可以使用二分查找的方法得到 $\text{left}$。
   细节
   注意到 $(1)$ 式的左侧的下标是 $\text{left}-1$ 而不是 $\text{left}$，那么我们在构造前缀和数组时，可以将前缀和整体向右移动一位，空出 $P[0]$ 的位置，即：
   $\{\begin{array}{l}P[0]=0\\ P[i]=P[i-1]+(1-A[i-1])\end{array}$
   此时，我们在数组 $P$ 上二分查找到的下标即为 $\text{left}$ 本身，同时我们也避免了原先$\text{left}=0$ 时 $\text{left}-1=-1$不在数组合法的下标范围中的边界情况。

class Solution {
public:
    int longestOnes(vector<int> &A, int K) {
        int n = A.size(),res=0;
        vector<int> sum(n + 1);
        for (int i = 1; i <= n; i++) {
            sum[i] = sum[i - 1] + (1-A[i - 1]);
        }
        for (int right = 0; right < n; right++) {
            int left = lower_bound(sum.begin(), sum.end(),sum[right+1]-K) - sum.begin();
            res = max(res, right - left + 1);
        }
        return res;
    }
};

2. 滑动窗口
   思路与算法
   我们继续观察 $(1)$ 式，由于前缀和数组 $P$ 是单调递增的，那么 $(1)$ 式的右侧 $P[\text{right}]-K$ 同样也是单调递增的。因此，我们可以发现：
   随着 $\text{right}$ 的增大，满足 $(1)$ 式的最小的 $\text{left}$ 值是单调递增的。
   这样一来，我们就可以使用滑动窗口来实时地维护 $\text{left}$ 和 $\text{right}$ 了。在 $\text{right}$ 向右移动的过程中，我们同步移动 $\text{left}$，直到 $\text{left}$ 为首个（即最小的）满足 $(1)$ 式的位置，此时我们就可以使用此区间对答案进行更新了。
   细节
   当我们使用滑动窗口代替二分查找解决本题时，就不需要显式地计算并保存出前缀和数组了。我们只需要知道 $\text{left}$ 和 $\text{right}$ 作为下标在前缀和数组中对应的值，因此我们只需要用两个变量 $\text{lsum}$ 和 $\text{rsum}$ 记录 $\text{left}$ 和 $\text{right}$ 分别对应的前缀和即可。

class Solution {
public:
    int longestOnes(vector<int> &A, int K) {
        int n = A.size(), res = 0, lsum = 0, rsum = 0, left = 0, right = 0;
        vector<int> sum(n + 1);
        while (right < n) {
            rsum += (1 - A[right]);
            while (rsum - lsum > K) {
                lsum += (1 - A[left]);
                left++;
            }
            res = max(res, right - left+1);
            right++;
        }
        return res;
    }
};