MaxConsecutiveOnesII487

Author: fluency03

Diff for: README.md

@@ -44,11 +44,11 @@
 | [Graph](https://github.com/fluency03/leetcode-java/blob/master/src/graph) |
 
 
-# Total: 296
+# Total: 297
 
 | Easy |  Medium | Hard | - |
 |:----:|:-------:|:----:|:-:|
-|  79  |   162   |  52  | 3 |
+|  79  |   163   |  52  | 3 |
 
 
 | Question | Solution | Difficulty |
@@ -297,6 +297,7 @@
 | [480. Sliding Window Median](https://leetcode.com/problems/sliding-window-median/) | [Solution](https://github.com/fluency03/leetcode-java/blob/master/src/SlidingWindowMedian480.java) | Hard |
 | [482. License Key Formatting](https://leetcode.com/problems/license-key-formatting/) | [Solution](https://github.com/fluency03/leetcode-java/blob/master/src/LicenseKeyFormatting482.java) | Easy |
 | [485. Max Consecutive Ones](https://leetcode.com/problems/max-consecutive-ones/) | [Solution](https://github.com/fluency03/leetcode-java/blob/master/src/MaxConsecutiveOnes485.java) | Easy |
+| [487. Max Consecutive Ones II](https://leetcode.com/problems/max-consecutive-ones-ii/description/) | [Solution](https://github.com/fluency03/leetcode-java/blob/master/src/MaxConsecutiveOnesII487.java) | Medium |
 | [490. The Maze](https://leetcode.com/problems/the-maze/) | [Solution](https://github.com/fluency03/leetcode-java/blob/master/src/TheMaze490.java) | Medium |
 | [503. Next Greater Element II](https://leetcode.com/problems/next-greater-element-ii/) | [Solution](https://github.com/fluency03/leetcode-java/blob/master/src/NextGreaterElementII503.java) | Medium |
 | [508. Most Frequent Subtree Sum](https://leetcode.com/problems/most-frequent-subtree-sum/) | [Solution](https://github.com/fluency03/leetcode-java/blob/master/src/MostFrequentSubtreeSum508.java) | Medium |

Diff for: src/MaxConsecutiveOnesII487.java

@@ -0,0 +1,46 @@
+/**
+ * Given a binary array, find the maximum number of consecutive 1s in this
+ * array if you can flip at most one 0.
+ * 
+ * Example 1:
+ * Input: [1,0,1,1,0]
+ * Output: 4
+ * Explanation: Flip the first zero will get the the maximum number of consecutive 1s.
+ *     After flipping, the maximum number of consecutive 1s is 4.
+ * 
+ * Note:
+ * The input array will only contain 0 and 1.
+ * The length of input array is a positive integer and will not exceed 10,000
+ * 
+ * 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?
+ */
+
+public class MaxConsecutiveOnesII487 {
+    public int findMaxConsecutiveOnes(int[] nums) {
+        if (nums == null || nums.length == 0) return 0;
+        int left = 0;
+        int right = 0;
+        int max = 0;
+        int zeros = 0;
+        while (right < nums.length) {
+            if (nums[right] == 1) {
+                right++;
+                continue;
+            } else if (nums[right] == 0 && zeros == 0) {
+                right++;
+                zeros++;
+                continue;
+            }
+            max = Math.max(max, right - left);
+            while (left < nums.length && nums[left] == 1) left++;
+            if (left < nums.length && nums[left] == 0) {
+                left++;
+                zeros--;
+            }
+        }
+        return Math.max(max, right-left);
+    }
+}