feat: add solutions to lc problem: No.0487

No.0487.Max Consecutive Ones II

Author: yanglbme

solution/0400-0499/0487.Max Consecutive Ones II/README.md

@@ -43,11 +43,21 @@
 
 <!-- 这里可写通用的实现逻辑 -->
 
-用 `prefix[i]` 数组表示以 $i$ 结尾往前累计的最大连续 1 的个数，`suffix[i]` 数组表示以 $i$ 开头往后累计的最大连续 1 的个数。
+**方法一：预处理 + 枚举**
 
-遍历 `nums` 数组每个为 0 的位置，则位置 $i$ 的最大连续 1 的个数为 `1 + prefix[i-1] + suffix[i+1]`。
+定义 `left`, `right` 数组表示以第 $i$ 个元素结尾（开头），往前（往后）累计的最大连续 $1$ 的个数。
 
-当然，如果 `nums` 数组没有 0，即所有元素都是 1，那么结果即为 `nums` 数组的长度。
+先遍历 `nums`，预处理出 `left` 和 `right`。
+
+然后枚举 `nums` 每个位置 $i$，统计以 $i$ 为分界点，左右两边最大连续 $1$ 的个数之和，取最大值即可。
+
+时间复杂度 $O(n)$，空间复杂度 $O(n)$。其中 $n$ 为 `nums` 的长度。
+
+**方法二：滑动窗口**
+
+找出最大的窗口，使得窗口内的 $0$ 的个数不超过 $1$ 个。
+
+时间复杂度 $O(n)$，空间复杂度 $O(1)$。其中 $n$ 为 `nums` 的长度。
 
 <!-- tabs:start -->
 
@@ -58,95 +68,228 @@
 ```python
 class Solution:
     def findMaxConsecutiveOnes(self, nums: List[int]) -> int:
+        ans = nums.count(1)
         n = len(nums)
-        prefix = [0] * n
-        suffix = [0] * n
-        res = 0
-        for i in range(n):
-            if i == 0:
-                prefix[i] = nums[i]
-            else:
-                prefix[i] = 0 if nums[i] == 0 else prefix[i - 1] + 1
-            res = max(res, prefix[i])
-
+        left = [0] * n
+        right = [0] * n
+        for i, v in enumerate(nums):
+            if v:
+                left[i] = 1 if i == 0 else left[i - 1] + 1
         for i in range(n - 1, -1, -1):
-            if i == n - 1:
-                suffix[i] = nums[i]
-            else:
-                suffix[i] = 0 if nums[i] == 0 else suffix[i + 1] + 1
-
-        for i in range(n):
-            if nums[i] == 0:
-                t = 1
-                if i > 0:
-                    t += prefix[i - 1]
-                if i < n - 1:
-                    t += suffix[i + 1]
-                res = max(res, t)
-        return res
+            v = nums[i]
+            if v:
+                right[i] = 1 if i == n - 1 else right[i + 1] + 1
+        ans = 0
+        for i, v in enumerate(nums):
+            t = 0
+            if i:
+                t += left[i - 1]
+            if i < n - 1:
+                t += right[i + 1]
+            ans = max(ans, t + 1)
+        return ans
+```
+
+```python
+class Solution:
+    def findMaxConsecutiveOnes(self, nums: List[int]) -> int:
+        ans = 1
+        cnt = j = 0
+        for i, v in enumerate(nums):
+            if v == 0:
+                cnt += 1
+            while cnt > 1:
+                if nums[j] == 0:
+                    cnt -= 1
+                j += 1
+            ans = max(ans, i - j + 1)
+        return ans
 ```
 
 ### **Java**
 
 <!-- 这里可写当前语言的特殊实现逻辑 -->
 
--   双指针，时间复杂度 $O(n^2)$，空间复杂度 $O(1)$
-
 ```java
 class Solution {
     public int findMaxConsecutiveOnes(int[] nums) {
         int n = nums.length;
-        int res = 0;
+        int[] left = new int[n];
+        int[] right = new int[n];
+        for (int i = 0; i < n; ++i) {
+            if (nums[i] == 1) {
+                left[i] = i == 0 ? 1 : left[i - 1] + 1;
+            }
+        }
+        for (int i = n - 1; i >= 0; --i) {
+            if (nums[i] == 1) {
+                right[i] = i == n - 1 ? 1 : right[i + 1] + 1;
+            }
+        }
+        int ans = 0;
         for (int i = 0; i < n; ++i) {
-            int cnt = 1;
-            int j = i;
-            while (j < n && (cnt > 0 || nums[j] == 1)) {
-                if (nums[j] == 0) --cnt;
-                ++j;
+            int t = 0;
+            if (i > 0) {
+                t += left[i - 1];
+            }
+            if (i < n - 1) {
+                t += right[i + 1];
             }
-            res = Math.max(res, j - i);
+            ans = Math.max(ans, t + 1);
         }
-        return res;
+        return ans;
     }
 }
 ```
 
--   辅助数组，时间复杂度 $O(n)$，空间复杂度 $O(n)$
-
 ```java
 class Solution {
     public int findMaxConsecutiveOnes(int[] nums) {
-        int n = nums.length;
+        int j = 0, cnt = 0;
+        int ans = 1;
+        for (int i = 0; i < nums.length; ++i) {
+            if (nums[i] == 0) {
+                ++cnt;
+            }
+            while (cnt > 1) {
+                if (nums[j++] == 0) {
+                    --cnt;
+                }
+            }
+            ans = Math.max(ans, i - j + 1);
+        }
+        return ans;
+    }
+}
+```
 
-        int[] prefix = new int[n];
-        int[] suffix = new int[n];
+### **C++**
 
-        int res = 0;
+```cpp
+class Solution {
+public:
+    int findMaxConsecutiveOnes(vector<int>& nums) {
+        int n = nums.size();
+        vector<int> left(n), right(n);
         for (int i = 0; i < n; ++i) {
-            if (i == 0)
-                prefix[0] = nums[0];
-            else
-                prefix[i] = nums[i] == 0 ? 0 : prefix[i - 1] + 1;
-            res = Math.max(res, prefix[i]);
+            if (nums[i]) {
+                left[i] = i == 0 ? 1 : left[i - 1] + 1;
+            }
         }
-
-        for (int i = n - 1; i >= 0; --i) {
-            if (i == n - 1)
-                suffix[n - 1] = nums[n - 1];
-            else
-                suffix[i] = nums[i] == 0 ? 0 : suffix[i + 1] + 1;
+        for (int i = n - 1; ~i; --i) {
+            if (nums[i]) {
+                right[i] = i == n - 1 ? 1 : right[i + 1] + 1;
+            }
         }
-
+        int ans = 0;
         for (int i = 0; i < n; ++i) {
+            int t = 0;
+            if (i) {
+                t += left[i - 1];
+            }
+            if (i < n - 1) {
+                t += right[i + 1];
+            }
+            ans = max(ans, t + 1);
+        }
+        return ans;
+    }
+};
+```
+
+```cpp
+class Solution {
+public:
+    int findMaxConsecutiveOnes(vector<int>& nums) {
+        int ans = 1;
+        int cnt = 0, j = 0;
+        for (int i = 0; i < nums.size(); ++i) {
             if (nums[i] == 0) {
-                int t = 1;
-                if (i > 0) t += prefix[i - 1];
-                if (i < n - 1) t += suffix[i + 1];
-                res = Math.max(res, t);
+                ++cnt;
+            }
+            while (cnt > 1) {
+                if (nums[j++] == 0) {
+                    --cnt;
+                }
             }
+            ans = max(ans, i - j + 1);
         }
-        return res;
+        return ans;
     }
+};
+```
+
+### **Go**
+
+```go
+func findMaxConsecutiveOnes(nums []int) int {
+	n := len(nums)
+	left := make([]int, n)
+	right := make([]int, n)
+	for i, v := range nums {
+		if v == 1 {
+			if i == 0 {
+				left[i] = 1
+			} else {
+				left[i] = left[i-1] + 1
+			}
+		}
+	}
+	for i := n - 1; i >= 0; i-- {
+		if nums[i] == 1 {
+			if i == n-1 {
+				right[i] = 1
+			} else {
+				right[i] = right[i+1] + 1
+			}
+		}
+	}
+	ans := 0
+	for i := range nums {
+		t := 0
+		if i > 0 {
+			t += left[i-1]
+		}
+		if i < n-1 {
+			t += right[i+1]
+		}
+		ans = max(ans, t+1)
+	}
+	return ans
+}
+
+func max(a, b int) int {
+	if a > b {
+		return a
+	}
+	return b
+}
+```
+
+```go
+func findMaxConsecutiveOnes(nums []int) int {
+	ans := 1
+	j, cnt := 0, 0
+	for i, v := range nums {
+		if v == 0 {
+			cnt++
+		}
+		for cnt > 1 {
+			if nums[j] == 0 {
+				cnt--
+			}
+			j++
+		}
+		ans = max(ans, i-j+1)
+	}
+	return ans
+}
+
+func max(a, b int) int {
+	if a > b {
+		return a
+	}
+	return b
 }
 ```