Problem:
Score : 400 points

Problem Statement

N people are arranged in a row from left to right.

You are given a string S of length N consisting of 0 and 1, and a positive integer K.

The i-th person from the left is standing on feet if the i-th character of S is 0, and standing on hands if that character is 1.

You will give the following direction at most K times (possibly zero):

Direction: Choose integers l and r satisfying 1 \leq l \leq r \leq N, and flip the l-th, (l+1)-th, ..., and r-th persons. That is, for each i = l, l+1, ..., r, the i-th person from the left now stands on hands if he/she was standing on feet, and stands on feet if he/she was standing on hands.

Find the maximum possible number of consecutive people standing on hands after at most K directions.

Constraints

N is an integer satisfying 1 \leq N \leq 10^5.

K is an integer satisfying 1 \leq K \leq 10^5.

The length of the string S is N.

Each character of the string S is 0 or 1.

Input

Input is given from Standard Input in the following format:

N K
S

Output

Print the maximum possible number of consecutive people standing on hands after at most K directions.

Sample Input 1

5 1
00010

Sample Output 1

4

We can have four consecutive people standing on hands, which is the maximum result, by giving the following direction:

Give the direction with l = 1, r = 3, which flips the first, second and third persons from the left.

Sample Input 2

14 2
11101010110011

Sample Output 2

8

Sample Input 3

1 1
1

Sample Output 3

1

No directions are necessary.

Solution in C# (Mono 4.6.2.0) (judge verdict: Wrong Answer)

using System ; 
 
namespace Program{
 class Program{
  static void Main(string[] args){
   string []buff = Console.ReadLine().Split(' ');
   int N = int.Parse(buff[0]);
   int K = int.Parse(buff[1]);
   
   int count = 0 ;
   int []L = new int[100005];
   int []R = new int[100005];
   
   for(int i = 0 ; i < L.Length ;i++){
     L[i] = -1;
     R[i] = -1;
   }
   string str = Console.ReadLine() ; 
     

   for(int i = 0 ;i < N ;i++){
     if( str[i] == '1' && L[count] == -1){
       L[count] = i+1; 
       while( i < N && str[i] == '1'  ){
         i++; 
       }
       R[count] = i  ;
       count++;
     }
   }
   
    
    
   int index = 0 ;
   int max = 0 ;
   if( count >= 2){
      for(int i = 0 ;i < count - 1 ;i++){
        if( R[i+1] - L[i] > max) index = i;
      }
   }else if(count == 1){
     index = 0 ;
   }else if( count == 0 ){
     Console.WriteLine(N);
     return ;
   }
    
   int left_index = index-1;
   int right_index = index+1;
   
    
   while(K > 0){
     if( right_index >= count && left_index < 0) break;
     
     if( left_index < 0 ){
       R[index] = R[right_index];
       right_index++;
     }else if( right_index >= count){
       L[index] = L[left_index] ;
       left_index--;
     }
     else if(  R[right_index] - L[index] > R[index] - L[left_index] ){
       R[index] = R[right_index];
       right_index++;
     }else{
       L[index] = L[left_index] ;
       left_index--;
     }
     K--;
   }
   
   while( K > 0 ){
     if( L[index] > 0 && R[index] < N ){
       if( L[index] > N - R[index] + 1){
         L[index] = 1 ;
       }
       else if( L[index] < N - R[index] + 1) R[index] = N ;
     }else if( L[index] == 1){
       R[index] = N ; 
     }else if( R[index] == N ){
       L[index] = 1 ;
     }else{
      break; 
     }
     K--;
   }
 
 
   max = R[index] - L[index] + 1;
   Console.WriteLine(max);
    
  }
 }
}