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 (
	"bufio"
	"fmt"
	"os"
	"strconv"
)

var sc = bufio.NewScanner(os.Stdin)
var out = bufio.NewWriter(os.Stdout)

func main() {
	buf := make([]byte, 1024*1024)
	sc.Buffer(buf, bufio.MaxScanTokenSize)
	sc.Split(bufio.ScanWords)
	defer out.Flush()
	N, K := nextInt(), nextInt()
	S := chars(next())
	boundary := []int{}
	j := 0
	for i := 1; i < N; i++ {
		if S[i-1] != S[i] {
			boundary = append(boundary, i-j)
			j = i
		}
	}
	boundary = append(boundary, N-j)
	// A[0]=0のとき
	//	00..11..00..11..00... -> 最初だけK*2, 次からはK*2+1の範囲
	// A[0]=1のとき最初は2K個、次からは2K+1個の範囲
	//	11..00..11..00..11.. -> K*2+1個の範囲
	ans := 0
	if S[0] == "0" {
		boundary = append([]int{1}, boundary...)
		// fmt.Printf("satart by 1: boundary = %v\n", boundary)
		r := 1
		tmp := 0
		for l := 1; l < len(boundary); l++ {
			for r < len(boundary) && (r-l) < 2*K {
				tmp += boundary[r]
				r++
			}
			// fmt.Printf("l, r = %d, %d, tmp = %d\n", l, r, tmp)
			ans = max(ans, tmp)
			tmp -= boundary[l]
			if l == r {
				r++
			}
		}
	} else if S[0] == "1" {
		r := 0
		tmp := 0
		for l := 0; l < len(boundary); l++ {
			for r < len(boundary) && (r-l) < 2*K+1 {
				tmp += boundary[r]
				r++
			}
			ans = max(ans, tmp)
			tmp -= boundary[l]
			if l == r {
				r++
			}
		}
	}
	fmt.Fprintln(out, ans)
}

func min(a, b int) int {
	if a < b {
		return a
	}
	return b
}

func max(a, b int) int {
	if a < b {
		return b
	}
	return a
}

func next() string {
	sc.Scan()
	return sc.Text()
}

func nextInt() int {
	a, _ := strconv.Atoi(next())
	return a
}

func nextInts(n int) []int {
	ret := make([]int, n)
	for i := 0; i < n; i++ {
		ret[i] = nextInt()
	}
	return ret
}

func nextStrings(n int) []string {
	ret := make([]string, n)
	for i := 0; i < n; i++ {
		ret[i] = next()
	}
	return ret
}

func chars(s string) []string {
	ret := make([]string, len([]rune(s)))
	for i, v := range []rune(s) {
		ret[i] = string(v)
	}
	return ret
}