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 OCaml (4.02.3) (judge verdict: Accepted)

let () = Scanf.scanf "%d %d\n%s\n" @@ fun n k s ->
  let seqs =
    Array.of_list @@ List.rev @@
    match
      (* 1111 0000 *)
      Array.fold_left (fun (acc, s) c ->
        match s, c with
        | `Ones n, '1' -> (acc, `Ones (n + 1))
        | `Zeros (n, m), '0' -> (acc, `Zeros (n, m + 1))
        | `Ones n, '0' -> (acc, `Zeros (n, 1))
        | `Zeros (n, m), '1' -> ((n, m) :: acc, `Ones 1)) ([], `Ones 0) @@
      Array.init (String.length s) (String.get s)
    with
    | (acc, `Ones n) -> (n, 0) :: acc
    | (acc, `Zeros (n, m)) -> (n, m) :: acc in
  if Array.length seqs <= k
  then Printf.printf "%d\n" n
  else begin
    let acc = Array.make (Array.length seqs + 1) 0 in
    for i = 0 to Array.length seqs - 1 do
      acc.(i + 1) <- acc.(i) + fst seqs.(i) + snd seqs.(i)
    done;
    Printf.printf "%d\n" @@
    Array.fold_left max (acc.(Array.length seqs) - acc.(Array.length seqs - k)) @@
    Array.init (Array.length seqs - k) @@ fun i ->
      acc.(i + k) - acc.(i) + fst seqs.(i + k)
  end