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 AtcoderTemplateForCSharp
{
    public class DFS
    {
        public static int Search(Node root)
        {
            if (root == null)
            {
                return -1;
            }

            var tmpMax = -1;

            Visit(root);
            root.Visited = true;
            if (root.Children != null)
            {
                foreach (var node in root.Children)
                {
                    if (!node.Visited)
                    {
                        tmpMax = Math.Max(tmpMax, Search(node));
                    }
                }
            }

            return tmpMax;
        }

        private static int Visit(Node root)
        {
            // nop

            var resultList = new List<int>();

            var beforeIsOne = true;
            var oneCount = 0;

            var zeroStartIndex = -1;
            var zeroEndIndex = -1;

            var beforeIsZero = false;
            var zeroCount = 0;

            var one1Count = 0;
            var one2Count = 0;

            var zero1Count = 0;

            var flagA = false;
            var flagB = false;

            for (int i = 0; i < root.Numbers.Count; i++)
            {
                //if (i == 0)
                //{
                //    // コーナーケース

                //    //if (root.Numbers[i] == 1)
                //    //{
                //    //    oneCount++;

                //    //    // 0 -> 1
                //    //    if (true)
                //    //    {

                //    //    }

                //    //    beforeIsOne = true;
                //    //    beforeIsZero = false;
                //    //    zeroCount = 0;
                //    //}
                //    //else
                //    //{
                //    //    zeroCount++;

                //    //    // 1 -> 0
                //    //    if (beforeIsOne)
                //    //    {
                //    //        one1Count = oneCount;
                //    //        flagA = true;
                //    //    }

                //    //    beforeIsOne = false;
                //    //    beforeIsZero = true;
                //    //    oneCount = 0;
                //    //}
                //    continue;
                //}

                if (root.Numbers[i] == 1)
                {
                    oneCount++;

                    // 0 -> 1
                    if (beforeIsZero)
                    {
                        zeroEndIndex = i - 1;

                        zero1Count = zeroCount;
                        flagB = true;
                    }

                    beforeIsOne = true;
                    beforeIsZero = false;
                    zeroCount = 0;
                }
                else
                {
                    zeroCount++;

                    // 1 -> 0 (2回目)
                    if (beforeIsOne && flagA && flagB)
                    {
                        var newNode = new Node();

                        var newNumbers = new List<int>();

                        foreach (var number in root.Numbers)
                        {
                            newNumbers.Add(number);
                        }

                        var umeFlag = false;

                        for (int hoge = 0; hoge < newNumbers.Count; hoge++)
                        {
                            if (hoge == zeroStartIndex)
                            {
                                umeFlag = true;
                            }

                            if (hoge == zeroEndIndex)
                            {
                                newNumbers[hoge] = 1;

                                umeFlag = false;
                            }

                            if (umeFlag)
                            {
                                newNumbers[hoge] = 1;
                            }
                        }

                        newNode.Numbers = newNumbers;

                        // 逆立ち最大人数をresultListに代入する。

                        var itiCount = new List<int>();
                        var itiCountLocal = 0;
                        foreach (var number in newNumbers)
                        {
                            if (number == 1)
                            {
                                itiCountLocal++;
                            }
                            else
                            {
                                itiCount.Add(itiCountLocal);
                                itiCountLocal = 0;
                            }
                        }

                        resultList.Add(itiCount.Max()); // ここで代入した。

                        root.Children.Add(newNode);

                        flagA = false;
                        flagB = false;

                        zeroStartIndex = i;

                        one1Count = oneCount;
                        flagA = true;
                    }

                    // 1 -> 0
                    if (beforeIsOne)
                    {
                        zeroStartIndex = i;

                        one1Count = oneCount;
                        flagA = true;
                    }

                    beforeIsOne = false;
                    beforeIsZero = true;
                    oneCount = 0;
                }
            }

            if (resultList.Count == 0)
            {
                return -1;
            }
            else
            {
                return resultList.Max();
            }
        }
    }

    public class Node
    {
        public bool Visited { get; set; }

        public List<Node> Children { get; set; }

        public List<int> Numbers { get; set; }

        public Node()
        {
            Children = new List<Node>();
        }
    }

    public class Program
    {
        public static void Main(string[] args)
        {
            var input = Console.ReadLine()
                .Split(' ')
                .Select(int.Parse);

            var n = input.ElementAt(0);
            var k = input.ElementAt(1);

            var s = Console.ReadLine()
                .Select(x => int.Parse(x.ToString()))
                .ToList();

            var node = new Node();


            node.Numbers = s;

            var max = DFS.Search(node);

            Console.WriteLine(max);
        }
    }
}