[LeetCode] 1004. 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. 

 

Example 1:

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.

Example 2:

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.

 

Note:

1. 1 <= A.length <= 20000
2. 0 <= K <= A.length
3. A[i] is 0 or 1 

 

O(n) solution with two pointers to go through the input array. All subarrays of 1s must be contiguous is a hint that we should use two pointers, left for the start index, right for the end index of a subarrays of all 1s.

Algorithm: As long as there are still unchecked elements, do (a) if there are no change quote left and the current element is 0,  compute the current subarry of 1s' length and update the max length if needed, then move the left pointer to point to the next element of the first 0 that was changed to 1.  This means we just release one change quote so that the right pointer can move forward by 1. (b) if there are change quotes left and the current element is 0, simply decrement the quote by 1. (c) move forward right by 1. After we've checked all elements in the while loop, don't forget to compute the length of subarray that ends at the last element.

 

Key notes:

in case a, there is no need to update the change quote K because we advance the left pointer to exclude the first 0 that was flipped and we also advance right to include the current 0.

 

class Solution {
    public int longestOnes(int[] A, int K) {
        int left = 0, right = 0, len = 0;
        while(right < A.length) {
            if(K == 0 && A[right] == 0) {
                len = Math.max(len, right - left);
                while(left <= right && A[left] != 0) {
                    left++;
                }
                left++;
            }
            else if(A[right] == 0){
                K--;
            }
            right++;
        }
        len = Math.max(len, right - left);
        return len;
    }
}