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 (
  "container/list"
  "fmt"
  "os"
)
func main() {
  var n,k,r,m int
  var s string
  var a []int
  fmt.Scan(&n,&k)
  fmt.Scan(&s)
  a = make([]int,n)
  r = 1
  if s[0:1] == "0" { r = -1 }
  a[0] = r
  p2n := list.New()
  n2p := list.New()
  for i:=1;i<n;i++ {
    if s[i:i+1] == s[i-1:i] {
      a[i] = a[i-1] + r
    } else {
      if r > 0 {
        p2n.PushBack(i-1)
      } else {
        n2p.PushBack(i-1)
      }
      r = -r
      a[i] = r
    }
  }
  if a[n-1] > 0 {
    p2n.PushBack(n-1)
  } else {
    n2p.PushBack(n-1)
  }
  if p2n.Len() == 0 || n2p.Len() == 0 {
    fmt.Println(abs(a[n-1]))
    os.Exit(0)
  }
  used_p2n := list.New()
  used_n2p := list.New()
  m = 0
  if p2n.Len() == n2p.Len() && a[n-1] > 0 ||
  p2n.Len() != n2p.Len() && a[n-1] < 0 {
    j,_ := n2p.Remove(n2p.Front()).(int)
    m -= a[j]
    k--
    used_n2p.PushBack(j)
  }
  j,_ := p2n.Remove(p2n.Front()).(int)
  m += a[j]
  used_p2n.PushBack(j)
  for c:=0;c<k;c++ {
    if p2n.Len() == 0 { break }
    x,_ := p2n.Remove(p2n.Front()).(int)
    m += a[x]
    used_p2n.PushBack(x)
    if n2p.Len() == 0 { break }
    y,_ := n2p.Remove(n2p.Front()).(int)
    m -= a[y]
    used_n2p.PushBack(y)
  }
  for {
    if p2n.Len() == 0 { break }
    x,_ := p2n.Remove(p2n.Front()).(int)
    m += a[x]
    used_p2n.PushBack(x)
    if n2p.Len() == 0 { break }
    y,_ := n2p.Remove(n2p.Front()).(int)
    m -= a[y]
    used_n2p.PushBack(y)
    p,_ := used_p2n.Remove(used_p2n.Front()).(int)
    q,_ := used_n2p.Remove(used_n2p.Front()).(int)
    m += -a[p]+a[q]
  }
  fmt.Println(m)
}
func abs(n int) int {
  if n < 0 { return -n }
  return n
}