LeetCode 0487. Max Consecutive Ones II Solution in Java, Python, C++, JavaScript, Go & Rust | Explanation + Code

Description

Given a binary array nums, return the maximum number of consecutive 1's in the array if you can flip at most one 0.

 

Example 1:

Input: nums = [1,0,1,1,0]
Output: 4
Explanation: 
- If we flip the first zero, nums becomes [1,1,1,1,0] and we have 4 consecutive ones.
- If we flip the second zero, nums becomes [1,0,1,1,1] and we have 3 consecutive ones.
The max number of consecutive ones is 4.

Example 2:

Input: nums = [1,0,1,1,0,1]
Output: 4
Explanation: 
- If we flip the first zero, nums becomes [1,1,1,1,0,1] and we have 4 consecutive ones.
- If we flip the second zero, nums becomes [1,0,1,1,1,1] and we have 4 consecutive ones.
The max number of consecutive ones is 4.

 

Constraints:

• 1 <= nums.length <= 105
• nums[i] is either 0 or 1.

 

Follow up: What if the input numbers come in one by one as an infinite stream? In other words, you can't store all numbers coming from the stream as it's too large to hold in memory. Could you solve it efficiently?

Solutions

Solution 1: Sliding Window

We can iterate through the array, using a variable cnt to record the current number of 0s in the window. When cnt > 1, we move the left boundary of the window to the right by one position.

After the iteration ends, the length of the window is the maximum number of consecutive 1s.

Note that in the process above, we do not need to loop to move the left boundary of the window to the right. Instead, we directly move the left boundary to the right by one position. This is because the problem asks for the maximum number of consecutive 1s, so the length of the window will only increase, not decrease. Therefore, we do not need to loop to move the left boundary to the right.

The time complexity is O(n), where n is the length of the array. The space complexity is O(1).

PythonJavaC++GoTypeScriptJavaScript

class Solution: def findMaxConsecutiveOnes(self, nums: List[int]) -> int: l = cnt = 0 for x in nums: cnt += x ^ 1 if cnt > 1: cnt -= nums[l] ^ 1 l += 1 return len(nums) - l(code-box)

class Solution { public int findMaxConsecutiveOnes(int[] nums) { int l = 0, cnt = 0; for (int x : nums) { cnt += x ^ 1; if (cnt > 1) { cnt -= nums[l++] ^ 1; } } return nums.length - l; } }(code-box)

class Solution { public: int findMaxConsecutiveOnes(vector<int>& nums) { int l = 0, cnt = 0; for (int x : nums) { cnt += x ^ 1; if (cnt > 1) { cnt -= nums[l++] ^ 1; } } return nums.size() - l; } };(code-box)

func findMaxConsecutiveOnes(nums []int) int { l, cnt := 0, 0 for _, x := range nums { cnt += x ^ 1 if cnt > 1 { cnt -= nums[l] ^ 1 l++ } } return len(nums) - l }(code-box)

function findMaxConsecutiveOnes(nums: number[]): number { let [l, cnt] = [0, 0]; for (const x of nums) { cnt += x ^ 1; if (cnt > 1) { cnt -= nums[l++] ^ 1; } } return nums.length - l; }(code-box)

/** * @param {number[]} nums * @return {number} */ var findMaxConsecutiveOnes = function (nums) { let [l, cnt] = [0, 0]; for (const x of nums) { cnt += x ^ 1; if (cnt > 1) { cnt -= nums[l++] ^ 1; } } return nums.length - l; };(code-box)