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 Rust (1.15.1) (judge verdict: Time Limit Exceeded)

use std::io::Read;

fn main() {
    let mut buf = String::new();

    // 標準入力から全部bufに読み込む
    std::io::stdin().read_to_string(&mut buf).unwrap();

    // 読み込んだStringを空白で分解する
    let mut iter = buf.split_whitespace();

    let n: u32 = iter.next().unwrap().parse().unwrap();
    let k: u32 = iter.next().unwrap().parse().unwrap();
    let st = iter.next().unwrap();

    let mut vec: Vec<Stand> = Vec::new();

    for i in 0..st.len() {
        let s = &st[i..i + 1];
        match vec.pop() {
            None => {
                if s == "0" {
                    vec.push(Stand::Stand(1));
                } else if s == "1" {
                    vec.push(Stand::HandStand(1));
                }
            }
            Some(stand) => {
                match stand {
                    Stand::Stand(i) => {
                        if s == "0" {
                            vec.push(Stand::Stand(i + 1));
                        } else if s == "1" {
                            vec.push(Stand::Stand(i));
                            vec.push(Stand::HandStand(1));
                        }
                    }
                    Stand::HandStand(i) => {
                        if s == "0" {
                            vec.push(Stand::HandStand(i));
                            vec.push(Stand::Stand(1));
                        } else if s == "1" {
                            vec.push(Stand::HandStand(i + 1));
                        }
                    }
                }
            }
        }
    }

    let mut high_score = 0;
    for i in 0..vec.len() {
        // i番目から初めていくつまで行けるか
        let mut score = 0;
        let mut jump_count = 0;
        for j in i..vec.len() {
            match vec[j] {
                Stand::HandStand(i) => {
                    score += i;
                }
                Stand::Stand(i) => {
                    if jump_count >= k { break; }
                    score += i;
                    jump_count += 1;
                }
            }
        }
        if score > high_score { high_score = score; }
    }

    println!("{}", high_score);
}

enum Stand {
    Stand(u32),
    HandStand(u32),
}