1004. 最大连续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。

提示：

1 <= A.length <= 20000
0 <= K <= A.length
A[i] 为 0 或 1 

来源：力扣（LeetCode）1004. 最大连续1的个数 III
链接：https://leetcode-cn.com/problems/max-consecutive-ones-iii

法一：滑动窗口

题目要求在一串连续的 0 1 之间找到满足要求的最大连续子串。其中K表示可以把0替换成1的次数。

分析：

比如对于 { 1,1,1,0,0,0,1,1,1,1,0 } K=2 而言。满足要求的最大连续子串长度为 6 。具体分析如下：

而根据题目要求，能达到的最大窗口宽度有两部分组成，{ 数字1的窗口，用0替代的窗口} 。则最大可达宽度为 wind+K 。

根据滑动窗口的做法，先变量 i 表示当前窗口左边界， 变量 j 表示当前窗口右边界。设置变量wind表示当前窗口中 1 的个数，设置变量maxWind表示最大的一个窗口宽度。

情况一：当前窗口 小于 最大可达窗口

该情况下，直接进行当前窗口的扩展即可。

1. 初始状态，当前值为 1 。 wind+=1。
   现最大可达宽度为 wind+K = 3 ，当前宽度为 (j - i + 1) = 1

2. j 向右试探，当前值为 1 ，wind += 1 。
   现最大可达宽度为 wind+K = 4 ，当前宽度为 (j - i + 1) = 2

3. j 向右试探，当前值为 1 ，wind += 1 。
现最大可达宽度为 wind+K = 5 ，当前宽度为 (j - i + 1) = 3

4. j 向右试探，当前值为 0 ，wind 不变。
   现最大可达宽度为 wind+K = 5 ，当前宽度为 (j - i + 1) = 4

5. j 向右试探，当前值为 1 ，wind 不变。
   现最大可达宽度为 wind+K = 5 ，当前宽度为 (j - i + 1) = 5

情况二：当前窗口 > 最大可达窗口

当我们的 当前窗口已经超出最大可达窗口时，即我们无法再继续的添加元素了，需要适当的减少窗口内的元素，空出空间方便我们继续向右扩展新窗口。

6. j 向右试探，当前值为 0 ，wind 不变 。
   现最大可达宽度为 wind+K = 5 ，当前宽度为 (j - i + 1) = 6 。
   当前窗口超出最大窗口，无法继续添加元素到窗口

1.记录现阶段窗口最大值。
2.移动窗口左边界，窗口内腾出位置后，继续向后试探（因为后面可能还存在更长的元素）。
3.注意，若取消的边界元素是1，对应的wind应该减小。
wind -= 1。现最大可达宽度为 wind+K = 4 ，当前宽度为 (j - i + 1) = 5 。
窗口任然无法没有空间存放新元素，则继续上述步骤移动窗口左边界。

现最大可达宽度为 wind+K = 3 ，当前宽度为 (j - i + 1) = 4 。
窗口任然无法没有空间存放新元素，则继续上述步骤移动窗口左边界。

现最大可达宽度为 wind+K = 2 ，当前宽度为 (j - i + 1) = 3 。
窗口任然无法没有空间存放新元素，则继续上述步骤移动窗口左边界。

情况一：当前窗口 小于 最大可达窗口

现最大可达宽度为 wind+K = 2 ，当前宽度为 (j - i + 1) = 1 。
可以继续添加新元素了。

将当前 arr[j] 元素添加到窗口，由于当前窗口中没有 1 ，最大可达窗口的宽度只有 2 个。

情况三：当前窗口 == 最大可达窗口，当前值为 1

此时需要判断，如果我们此时加入的元素为 1 ，则表示我们的最大可达窗口将会扩张（wind+=1）。
而此时加入的元素如果为 0 ，则会变成情况二：当前窗口 小于 最大可达窗口。

7. 此时arr[j] 值为 1 ，wind += 1 。则
   现最大可达宽度为 wind+K = 3 ，当前宽度为 (j - i + 1) = 3

8. j 向右试探，当前值为 1 ，wind += 1 。
   现最大可达宽度为 wind+K = 4 ，当前宽度为 (j - i + 1) = 4

8. j 向右试探，当前值为 1 ，wind += 1 。
   现最大可达宽度为 wind+K = 5 ，当前宽度为 (j - i + 1) = 5

8. j 向右试探，当前值为 1 ，wind += 1 。
   现最大可达宽度为 wind+K = 6 ，当前宽度为 (j - i + 1) = 6

情况四：当前窗口 == 最大可达窗口，当前值为 0

8. j 向右试探，当前值为 0 ，wind 不变。则
   现最大可达宽度为 wind+K = 6 ，当前宽度为 (j - i + 1) = 7
   此时，需要移动窗口左边界。
   注：在移动窗口之前，记得备份当前最大窗口宽度，即 maxWind = max(maxWind, j - i + 1);
   

9. 窗口左边界移动，即将4号下标位置从窗口中取出，把10号下标位置加入窗口。

通过以上四种步骤的处理方法，便足矣因对此题中的所有情况。而我们注意到maxWind每次都在窗口即将缩减时记录一次当前窗口的大小，并且maxWind只取最大值。

参考代码：

int longestOnes(vector<int>& A, int K) {
	int wind = 0, i = 0, j = 0;
	int maxWind = 0;
	while (j < A.size())
	{
		if (A[j] == 1)
		{
			wind++;	// 统计连续1的窗口
			j++;	// 窗口右边界扩张
		}
		else
		{
			// 当前为0，是否可以添加
			if ((j - i) >= wind + K)	// 当前窗口 是否超出 最大窗口
			{
				// 不可再添加，需要缩减左边界
				maxWind = std::max(maxWind, j - i);	// 记录当前最大窗口值
				if (A[i] == 1) wind--;	// 被移除的是否为 1
				i++;
			}
			else j++;
		}

	}
	maxWind = std::max(maxWind, j - i);
	return maxWind;
}

法二：二分查找

参考力扣官方题解。

分析：如图所示，蓝色部分是前缀和，表示当前元素之前有几个0。红色表示下标，黑色表示数据。

在 arr[5] 到 arr[10] 所在的区间里恰能达到最大。

在arr[10]所对应的前缀表prev[11]中，数字3表示在此之前共有3个0。我们用 prev[11] - K = 1，对应位置在prev[5]。即，此时arr[5] ~ arr[10] 之间恰有两个0，其余皆为 1 。

同理 arr[6] ~ arr[11] 之间也可以为最大。其对应前缀表为 prev[12] - K = prev[6] 。

参考代码：

int longestOnes(vector<int>& A, int K) 
{
	int n = A.size();
	// 前缀表：某元素左侧有几个0
	vector<int> P(n + 1);
	for (int i = 1; i <= n; ++i) {
		P[i] = P[i - 1] + (1 - A[i - 1]);
	}

	int ans = 0;
	for (int right = 0; right < n; ++right) {
	// 二分法找大于等于 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(\log n)$，我们需要枚举 $\text{right}$ 进行 n 次二分查找，因此总时间复杂度为 $O(n\log n)$。

空间复杂度：$O(n)$，即为前缀和数组 P 需要的空间。

参考代码：

int longestOnes(vector<int>& A, int K) {
	int n = A.size();
	// lsum记录左边界左侧0的个数
	// rsum记录右边界左侧0的个数
	int left = 0, lsum = 0, rsum = 0;
	int ans = 0;
	for (int right = 0; right < n; ++right) {
		rsum += 1 - A[right];
		// 维持窗口之间最多有K个0
		while (lsum < rsum - K) 
		{
			lsum += 1 - A[left];
			++left;
		}
		ans = max(ans, right - left + 1);
	}
	return ans;
}

复杂度分析

时间复杂度：$O(n)$，其中 n 是数组 A 的长度。我们至多只需要遍历该数组两次（左右指针各一次）。

空间复杂度：$O(1)$，我们只需要常数的空间保存若干变量。