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: Time Limit Exceeded)

using System;
using System.Linq;
using System.Collections.Generic;
class program
{
  static void Main()
  {
    string[] s_wk = Console.ReadLine().Split(' ');
    int N = int.Parse(s_wk[0]);
    int K = int.Parse(s_wk[1]);
    
    if( K >= (N + 1)/2 )
    {
      Console.WriteLine(N);
      return;
    }
    
    char[] S = Console.ReadLine().ToCharArray();
    
    List<int> i_S = new List<int>();

    int cnt = 0;
    if(S[0]=='1'){cnt++;}
    else{cnt--;}
    
    for(int i = 1 ; i < N - 1 ; i++)
    {
      if(S[i]=='1')
      {
        if(cnt>0){cnt++;}
        else{int i_wk = cnt;i_S.Add(i_wk);cnt=1;}
      }
      else
      {
        if(cnt>0){int i_wk = cnt;i_S.Add(i_wk);cnt=-1;}
        else{cnt--;}
      }
    }
    
    if(S[N-1]=='1')
    {
      if(cnt>0){cnt++;int i_wk = cnt;i_S.Add(i_wk);}
      else{int i_wk = cnt;i_S.Add(i_wk);i_S.Add(1);}
    }
    else
    {
      if(cnt>0){int i_wk = cnt;i_S.Add(i_wk);i_S.Add(-1);}
      else{cnt--;int i_wk = cnt;i_S.Add(i_wk);}
    }
    
    int rslt_max = 0;
    int rslt = 0;
    int rev = 0;
    for( int i = 0 ; i < i_S.Count ; i ++ )
    {
      rev=rslt=0;
      for( int j = i ; j < i_S.Count ; j++ )
      {
        if( i_S[j] < 0 )
        {
          if( rev < K )
          {
            rslt += (i_S[j] * (-1));
            if( rslt_max < rslt ){rslt_max=rslt;}
            rev++;
          }
          else
          {
            if( rslt_max < rslt ){rslt_max=rslt;}
            break;
          }
        }
        else
        {
            rslt += i_S[j];
            if( rslt_max < rslt ){rslt_max=rslt;}
        }
      }
    }
    Console.WriteLine(rslt_max);
  }
}