# 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.

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`

## 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;
}
}
``````