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: Accepted)

// This code is generated by [cargo-atcoder](https://github.com/tanakh/cargo-atcoder)
// Original source code:
/*
use libprocon::*;

fn main() {
    input! {
        N: usize,
        K: usize,
        S: chars,
    }
    let mut rl = Vec::with_capacity(N);
    let mut cur = S[0];
    let mut len = 0;
    for i in 0..N {
        if S[i] == cur {
            len += 1;
        } else {
            rl.push(len);
            len = 1;
            cur = S[i];
        }
    }
    rl.push(len);

    let mut rl_e = Vec::with_capacity(N);
    if S[0] == '0' {
        rl_e.push(0);
    }
    rl_e.append(&mut rl);
    if S[N - 1] == '0' {
        rl_e.push(0);
    }

    dbg!(&rl_e);

    let mut prev_val: usize = rl_e.iter().take(2 * K + 1).sum();
    let mut ans = prev_val;
    use std::cmp::max;
    let mut idx = 2;
    dbg!(prev_val);
    while idx <= rl_e.len() - 1 {
        let p2 = rl_e[idx - 2];
        let p1 = rl_e[idx - 1];
        let n1 = rl_e.get(idx + 2 * K - 1).unwrap_or(&0);
        let n2 = rl_e.get(idx + 2 * K).unwrap_or(&0);
        dbg!((p2, p1, n1, n2));
        let val = prev_val - p2 - p1 + n1 + n2;
        dbg!((idx, val));
        ans = max(ans, val);
        prev_val = val;
        idx += 2;
    }

    println!("{}", ans);
}
*/

fn main() {
    let exe = "/tmp/binE107B6D1";
    std::io::Write::write_all(&mut std::fs::File::create(exe).unwrap(), &decode(BIN)).unwrap();
    std::fs::set_permissions(exe, std::os::unix::fs::PermissionsExt::from_mode(0o755)).unwrap();
    std::process::exit(std::process::Command::new(exe).status().unwrap().code().unwrap())
}

fn decode(v: &str) -> Vec<u8> {
    let mut ret = vec![];
    let mut buf = 0;
    let mut tbl = vec![64; 256];
    for i in 0..64 { tbl[TBL[i] as usize] = i as u8; }
    for (i, c) in v.bytes().filter_map(|c| { let c = tbl[c as usize]; if c < 64 { Some(c) } else { None } }).enumerate() {
        match i % 4 {
            0 => buf = c << 2,
            1 => { ret.push(buf | c >> 4); buf = c << 4; }
            2 => { ret.push(buf | c >> 2); buf = c << 6; }
            3 => ret.push(buf | c),
            _ => unreachable!(),
        }
    }
    ret
}

const TBL: &'static [u8] = b"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
const BIN: &'static str = "<base64-encoded ELF executable removed>";