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 Go (1.6) (judge verdict: Wrong Answer)

package main

import (
	"fmt"
	"strings"
)

type Status struct {
	val string
	len int
}

func main() {
	n := SingleInt()
	k := SingleInt()
	s := SingleStr()
	ss := strings.Split(s, "")

	if len(ss) == 1 {
		fmt.Printf("%#v\n", 1)
		return
	}

	base := ss[0]
	mans := make([]*Status, 0, n)
	l := 1
	sta := &Status{val: base}
	for i := 1; i < n; i++ {
		if sta.val != ss[i] {
			mans = append(mans, &Status{val: sta.val, len: l})
			sta.val = ss[i]
			l = 1
		} else {
			l++
		}

		if i == n-1 {
			mans = append(mans, &Status{val: sta.val, len: l})
		}
	}

	var re int
	var ml int
	for i := 0; i < k; i++ {
		ml = len(mans)
		var mergeIdx int
		var sum int
		var hit bool
		for idx, sta := range mans {
			if sta.val == "0" {
				hit = true
				prev, next := &Status{len: 0}, &Status{len: 0}
				if idx != 0 {
					prev = mans[idx-1]
				}
				if idx+1 < ml {
					next = mans[idx+1]
				}
				tmp := sta.len + prev.len + next.len
				if sum < tmp {
					sum = tmp
					re = sum
					mergeIdx = idx
				}
			}
		}

		if !hit {
			fmt.Printf("%#v\n", re)
			return
		}

		prev, next := &Status{len: 0}, &Status{len: 0}
		if mergeIdx != 0 {
			prev = mans[mergeIdx-1]
		}
		if mergeIdx+1 < ml {
			next = mans[mergeIdx+1]
		}

		new := &Status{val: "1", len: mans[mergeIdx].len + prev.len + next.len}
		mans[mergeIdx] = new
		if next.len > 0 {
			mans = append(mans[:mergeIdx+1], mans[mergeIdx+1+1:]...)
		}
		if prev.len > 0 {
			mans = append(mans[:mergeIdx-1], mans[mergeIdx-1+1:]...)
		}
	}
	fmt.Printf("%#v\n", re)
}

func reverse(v string) string {
	if v == "0" {
		return "1"
	}
	return "0"
}

func SingleStr() string {
	var s string
	fmt.Scan(&s)
	return s
}

func SingleInt() int {
	var n int
	fmt.Scan(&n)
	return n
}