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;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace AtCorder_D
{
    class Program
    {
        const string test = "ababa";
        static void Main(string[] args)
        {
            var k = Console.ReadLine().Split(' ').Skip(1).Select(x => int.Parse(x)).First();
            var input2 = Console.ReadLine().Select(x => x == '1').ToArray();

            var xxx = new List<int>(); // 偶数は0、奇数は1
            bool now = false;
            int cnt = 0;
            foreach (bool x in input2)
            {
                if (x != now)
                {
                    xxx.Add(cnt);
                    cnt = 0;
                    now = !now;
                }
                cnt++;
            }
            xxx.Add(cnt);
            if (xxx.Count % 2 == 1)
            {
                xxx.Add(0);
            }

            for (int i = 0; i < k; i++)
            {
                int maxI = -1;
                int maxN = -1;
                for (int j = 1; j < xxx.Count; j += 2)
                {
                    int lll = xxx[j - 1] + (0 <= j - 2 ? xxx[j - 2] : 0);
                    int zzz = xxx[j] + lll;
                    if (maxN < zzz)
                    {
                        maxI = j;
                        maxN = zzz;
                    }
                }

                if (maxN == -1)
                {
                    break;
                }

                // 実際に反転
                else
                {
                    xxx[maxI] += xxx[maxI - 1];
                    xxx[maxI - 1] = 0;

                    if (0 <= maxI - 2)
                    {
                        xxx[maxI] += xxx[maxI - 2];
                        xxx.RemoveAt(maxI - 1);
                        xxx.RemoveAt(maxI - 2);

                    }
                }
            }

            int max = -1;
            for (int i = 1; i < xxx.Count; i += 2)
            {
                max = Math.Max(max, xxx[i]);
            }
            Console.WriteLine(max);
        }

        //static IEnumerable<long> sort(IEnumerator<long> a, IEnumerator<long> b, IEnumerator<long> c)
        //{
        //    a.MoveNext();
        //    long aa = a.Current;
        //    b.MoveNext();
        //    long bb = b.Current;
        //    c.MoveNext();
        //    long cc = c.Current;
        //    a.MoveNext();
        //    long an = a.Current;
        //    b.MoveNext();
        //    long bn = b.Current;
        //    c.MoveNext();
        //    long cn = c.Current;
        //    while (true)
        //    {
        //        yield return aa + bb + cc;
        //        long ass = aa - an;
        //        long bss = bb - bn;
        //        long css = cc - cn;
        //        if (ass <= bss && ass <= css)
        //        {
        //            aa = an;
        //            a.MoveNext();
        //            an = a.Current;
        //        }
        //        else if (bss <= css)
        //        {
        //            bb = bn;
        //            b.MoveNext();
        //            bn = b.Current;
        //        }
        //        else
        //        {
        //            cc = cn;
        //            c.MoveNext();
        //            cn = c.Current;
        //        }
        //    }
        //}
    }
}