【滑动窗口】最大连续1的个数Ⅲ

最大连续1的个数Ⅲ

1004. 最大连续1的个数 III - 力扣（LeetCode）

题目描述

给定一个二进制数组 nums 和一个整数 k，如果可以翻转最多 k 个 0 ，则返回 数组中连续 1 的最大个数 。

示例 1：

输入：nums = [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：

输入：nums = [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 <= nums.length <= 105
• nums[i] 不是 0 就是 1
• 0 <= k <= nums.length

算法原理

转化：找出最长的子数组，0 的个数不超过 k 个

暴力枚举

暴力枚举子数组 + zero计数器

代码编写

class Solution {
public:
    int longestOnes(vector<int>& nums, int k) {
        int ret = 0;
        for(int i = 0 ; i < nums.size(); i++)
        {
            int zero = 0;
            int count = 0;

            for(int j = i ; j < nums.size(); j++)
            {
                if(nums[j] == 0)
                {
                    if(zero < k)
                    {
                        zero++;
                        count++;
                    }
                    else break;
                }
                else count++;
            }
            ret = max(ret, count);
        }
        return ret;
    }
};

额哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈！

滑动窗口

不要去想怎么翻转，不要把问题想的很复杂，这道题的结果⽆⾮就是⼀段连续的 1 中间塞了 k个 0 嘛。

因此，我们可以把问题转化成：求数组中⼀段最⻓的连续区间，要求这段区间内 0 的个数不超过 k 个。

当right小于数组大小的时候，一直循环

1. 让元素进入窗口中
2. 检查0的元素是否会超过k
   • 如果超过了，依次让左侧元素出窗口，更新计数器的值，直到0的个数恢复正常
3. 更新结果
4. right++ 继续处理下一个元素

循环结束后，return ret即可~

1. left = 0, right = 0

2. 进窗口

   • 如果是1 无视
   • 如果是0 计数器+1

3. 判断

   zero > k

   出窗口

   更新结果

c++解法

class Solution {
public:
    int longestOnes(vector<int>& nums, int k) {
        int ret = 0;
        for(int left = 0, right = 0, zero = 0; right < nums.size(); right++)
        {
            // 进窗口
            if(nums[right] == 0) zero++;
            // 判断
            while(zero > k)
                if(nums[left++] == 0)   
                    zero--;
            // 更新结果
            ret = max(ret, right - left + 1);
        }
        return ret;
    }
};

class Solution {
public:
    int longestOnes(vector<int>& nums, int k) {
        int ret = 0; // 最大连续 1 的个数
        int zero = 0; // 0计数器
        int i = 0; // 左边界
        for(int j = 0; j < nums.size(); j ++)
        {
            if(nums[j] == 0)
                zero++;
            

            // 当翻转的 0 的个数超过 k 的时候， 更新左边界
            while(zero > k)
            {
                if(nums[i] == 0 )   
                    zero--;
                i++;
            }

            ret = max(ret, j - i + 1);
        }
        return ret;
    }
};

Java解法

class Solution {
    public int longestOnes(int[] nums, int k) {
        int ret = 0;
        for(int left = 0, right = 0, zero = 0; right < nums.length; right++)
        {
            // 进窗口
            if(nums[right] == 0) zero++;
            // 判断
            while(zero > k)
                if(nums[left++] == 0)   
                    zero--;
            // 更新结果
            ret = Math.max(ret, right - left + 1);
        }
        return ret;
    }
}

还是不错的~