1004. Max Consecutive Ones III (Medium)

https://leetcode.com/problems/max-consecutive-ones-iii/

Given an array A of 0s and 1s, we may change up to K values from 0 to 1.

Return the length of the longest (contiguous) subarray that contains only 1s. 

Input: A = [1,1,1,0,0,0,1,1,1,1,0], K = 2
Output: 6
Explanation: 
[1,1,1,0,0,1,1,1,1,1,1]
Bolded numbers were flipped from 0 to 1.  The longest subarray is underlined.

Input: A = [0,0,1,1,0,0,1,1,1,0,1,1,0,0,0,1,1,1,1], K = 3
Output: 10
Explanation: 
[0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,1,1,1,1]
Bolded numbers were flipped from 0 to 1.  The longest subarray is underlined.

Solutions

class Solution {

    // This solution is similar with 424. Longest Repeating Character Replacement (Medium)

    public int longestOnes(int[] A, int K) {
        if (A.length == 0) {
            return 0;
        }

        int max = 0;

        // count for 0
        int count0 = 0;

        // count for 1
        int count1 = 0;

        // left and right pointer
        int lptr = 0;
        int rptr = 0;

        while (true) {
            if (A[rptr] == 1) {
                count1++;
            } else {
                count0++;
            }

            // update the max length of repeating 1 if possible
            if (count0 == K && count0 + count1 > max) {
                max = count0 + count1;
            }

            // It is allowed only K replacements, no need to incorporate more than K other chars.
            while (count0 > K) {
                if (A[lptr] == 1) {
                    count1--;
                } else {
                    count0--;
                }

                lptr++;
            }

            // Do not overstep the boundary of the array.
            if (rptr == A.length - 1) {
                if(count0 + count1 > max) {
                    max = count0 + count1;
                }

                break;
            }

            rptr++;
        }

        return max;
    }
}

Incorrect Solutions

References