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 

Discuss

思路：先简化问题，先对连1进行计数，比如[1,1,1,0,0,0,1,1,1,1,0]计数就变成了[3,4]，附带另外一个数组[3]表示3,4中间有多少个0，即：只需要把这3个0变成1，就可以完成2部分连1的拼接，然后：

1. 贪心：肯定是要把连续的0替换成1，这样拼接起来的连1才最长

2. 基本上就转化为two pointer问题，找一个滑窗，里面的连0之和不超过K，而且连1最多

class Solution(object):
    def longestOnes(self, A, K):
        """
        :type A: List[int]
        :type K: int
        :rtype: int
        """
        left=len(A)-sum(A)
        if left<=K: return len(A)
        if sum(A)==0: return K
        
        profit=[]
        cost=[]
        i = 0
        while i<len(A) and A[i]==0: i+=1
        while i<len(A):
            j = i
            while j<len(A) and A[j]==1: j+=1
            profit.append(j-i)
            k = j
            while k<len(A) and A[k]==0: k+=1
            cost.append(k-j)
            i = k
        cost.pop()
#        print(profit)
#        print(cost)
        
        res = K+max(profit)
        i = j = used = 0
        contig = profit[0]
        while j<len(cost):
            while j<len(cost) and K-used>=cost[j]:
                used+=cost[j]
                contig += profit[j+1]  
                j+=1
            if i==j:
                i+=1
                j+=1
                continue
            res=max(res,contig+K)
            used-=cost[i]
            contig-=profit[i]
            i+=1
        return res