以下为力扣的官方题解
题目
给定一个由若干 0 0 0 和 1 1 1 组成的数组 A A A,我们最多可以将 K K K 个值从 0 0 0 变成 1 1 1 。
返回仅包含 1 1 1 的最长(连续)子数组的长度。
示例1
输入: A = [ 1 , 1 , 1 , 0 , 0 , 0 , 1 , 1 , 1 , 1 , 0 ] , K = 2 A = [1,1,1,0,0,0,1,1,1,1,0], K = 2 A=[1,1,1,0,0,0,1,1,1,1,0],K=2
输出: 6 6 6
解释: [1,1,1,0,0,1,1,1,1,1,1]
粗体数字从 0 0 0 翻转到 1 1 1,最长的子数组长度为 6 6 6。
示例2
输入: A = [ 0 , 0 , 1 , 1 , 0 , 0 , 1 , 1 , 1 , 0 , 1 , 1 , 0 , 0 , 0 , 1 , 1 , 1 , 1 ] , K = 3 A = [0,0,1,1,0,0,1,1,1,0,1,1,0,0,0,1,1,1,1], K = 3 A=[0,0,1,1,0,0,1,1,1,0,1,1,0,0,0,1,1,1,1],K=3
输出: 10 10 10
解释:[0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,1,1,1,1]
粗体数字从 0 0 0 翻转到 1 1 1,最长的子数组长度为 10 10 10。
提示
- 1 < = A . l e n g t h < = 20000 1 <= A.length <= 20000 1<=A.length<=20000
- 0 < = K < = A . l e n g t h 0 <= K <= A.length 0<=K<=A.length
- A [ i ] A[i] A[i] 为 0 0 0 或 1 1 1
官方题解
前言
对于数组 A A A 的区间 [ l e f t , r i g h t ] [left, right] [left,right] 而言,只要它包含不超过 K K K 个 0 0 0,我们就可以根据它构造出一段满足要求,并且长度为 r i g h t − l e f t + 1 right-left+1 right−left+1 的区间。
因此,我们可以将该问题进行如下的转化,即:
对于任意的右端点 r i g h t right right,希望找到最小的左端点 l e f t left left,使得 [ l e f t , r i g h t ] [left, right] [left,right] 包含不超过 K K K 个 0 0 0。
只要我们枚举所有可能的右端点,将得到的区间的长度取最大值,即可得到答案。
要想快速判断一个区间内 0 0 0 的个数,我们可以考虑将数组 A A A 中的 0 0 0 变成 1 1 1, 1 1 1 变成 0 0 0。此时,我们对数组 A A A 求出 前缀和,记为数组 P P P,那么 [ l e f t , r i g h t ] [left, right] [left,right] 中包含不超过 K K K 个 1 1 1(注意这里就不是 0 0 0 了),当且仅当二者的前缀和之差: P [ r i g h t ] − P [ l e f t − 1 ] ≤ K P[right]−P[left−1] \leq K P[right]−P[left−1]≤K。
这样一来,我们就可以容易地解决这个问题了。
方法一 二分查找
思路与算法
P [ r i g h t ] − P [ l e f t − 1 ] ≤ K P[right]−P[left−1] \leq K P[right]−P[left−1]≤K |
---|
等价于
P [ l e f t − 1 ] ≥ P [ r i g h t ] − K P[left-1] \geq P[right]-K P[left−1]≥P[right]−K | (1) |
---|
也就是说,我们需要找到最小的满足 (1) 式的 l e f t left left。由于数组 A A A 中仅包含 0 / 1 0/1 0/1,因此前缀和数组是一个单调递增的数组,我们就可以使用二分查找的方法得到 l e f t left left。
细节
注意到 (1) 式的左侧的下标是 l e f t − 1 left-1 left−1 而不是 l e f t left left,那么我们在构造前缀和数组时,可以将前缀和整体向右移动一位,空出 P [ 0 ] P[0] P[0] 的位置,即:
{ P [ 0 ] = 0 P [ i ] = P [ i − 1 ] + ( 1 − A [ i − 1 ] ) \begin{cases} P[0] = 0 \\ P[i] = P[i-1] + (1 - A[i-1]) \end{cases} {P[0]=0P[i]=P[i−1]+(1−A[i−1]) |
---|
此时,我们在数组 P P P 上二分查找到的下标即为 l e f t left left 本身,同时我们也避免了原先 l e f t = 0 left = 0 left=0 时 l e f t − 1 = − 1 left-1 = -1 left−1=−1 不在数组合法的下标范围中的边界情况。
代码
class Solution {
public int longestOnes(int[] A, int K) {
int n = A.length;
int[] P = new int[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++)
{
int left = binarySearch(P, P[right+1]-K);
ans = Math.max(ans, right-left+1);
}
return ans;
}
public int binarySearch(int[] P, int target) {
int low = 0, high = P.length-1;
while (low < high)
{
int mid = (high-low) / 2 + low;
if (P[mid] < target)
{
low = mid+1;
}
else
{
high = mid;
}
}
return low;
}
}
复杂度分析
- 时间复杂度: O ( n log n ) O(n \log n) O(nlogn),其中 n n n 是数组 A A A 的长度。每一次二分查找的时间复杂度为 O ( log n ) O(\log n) O(logn),我们需要枚举 r i g h t right right 进行 n n n 次二分查找,因此总时间复杂度为 O ( n log n ) O(n \log n) O(nlogn)。
- 空间复杂度: O ( n ) O(n) O(n)。即为前缀和数组 P P P 需要的空间。
方法二 滑动窗口
思路与算法
我们继续观察 (1) 式,由于前缀和数组 P P P 是单调递增的,那么 (1) 式的右侧 P [ r i g h t ] − K P[right]-K P[right]−K 同样也是单调递增的。因此,我们可以发现:
随着 r i g h t right right 的增大,满足 (1) 式的最小的 l e f t left left 值也是单调递增的。
这样一来,我们就可以使用滑动窗口来实时地维护 l e f t left left 和 r i g h t right right 了。在 r i g h t right right 向右移动的过程中,我们同步移动 l e f t left left,直到 l e f t left left 为首个(即最小的)满足 (1) 式的位置,此时我们就可以使用此区间对答案进行更新了。
细节
当我们使用滑动窗口代替二分查找解决本题时,就不需要显式地计算并保存出前缀和的数组了。我们只需要知道 l e f t left left 和 r i g h t right right 作为下标在前缀和数组中对应的值,因此我们只需要用两个变量 l s u m lsum lsum 和 r s u m rsum rsum 记录 l e f t left left 和 r i g h t right right 分别对应的前缀和即可。
代码
class Solution {
public int longestOnes(int[] A, int K) {
int n = A.length;
int left = 0, lsum = 0, rsum = 0;
int ans = 0;
for (int right=0; right<n; right++)
{
rsum += 1-A[right];
while (lsum < rsum-K)
{
lsum += 1-A[left];
left ++;
}
ans = Math.max(ans, right-left+1);
}
return ans;
}
}
复杂度分析
- 时间复杂度: O ( n ) O(n) O(n),其中 n n n 是数组 A A A 的长度。我们至多只需要遍历该数组两次(左右指针各一次)。
- 空间复杂度: O ( 1 ) O(1) O(1),我们只需要常数的空间保存若干变量。