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)

#[allow(unused_macros)]
macro_rules! get {
    ([$t:ty] ; $n:expr) => {
        (0..$n)
        .map(|_| get!([$t])).collect::<Vec<_>>()
    };
    ($($t:ty),+ ; $n:expr) => {
        (0..$n).map(|_| get!($($t),+)).collect::<Vec<_>>()
    };
    ([$t:ty]) => {
        rl().split_whitespace()
        .map(|x| x.parse().unwrap())
        .collect::<Vec<$t>>()
    };
    ($t:ty) => {
        rl().parse::<$t>().unwrap()
    };
    ($($t:ty),*) => {
        {
            let line =rl();
            let mut iter = line.split_whitespace();
            ($(iter.next().unwrap().parse::<$t>().unwrap()),*)
        }
    };
}
fn rl() -> String {
    let mut line = String::new();
    std::io::stdin().read_line(&mut line).unwrap();
    line.trim().to_string()
}

fn main() {
    let (n, k) = get!(usize, usize);
    let cc: Vec<char> = get!(String).chars().collect();
    let mut v = Vec::new();
    let mut pre_zero;
    let mut pre_one;
    if cc[0] == '0' {
        pre_zero = true;
        pre_one = false;
    } else {
        pre_zero = false;
        pre_one = true;
    }
    let mut zero = 0;
    let mut one = 0;
    let mut zero_count = 0;
    for i in 0..cc.len() {
        if cc[i] == '0' {
            zero += 1;
            if !pre_zero {
                v.push((1, one));
                one = 0;
            }
            pre_zero = true;
            pre_one = false;
        } else if cc[i] == '1' {
            one += 1;
            if !pre_one {
                v.push((0, zero));
                zero = 0;
                zero_count += 1;
            }
            pre_zero = false;
            pre_one = true;
        }
    }
    if zero != 0 {
        v.push((0, zero));
        zero_count += 1;
    } else {
        v.push((1, one));
    }
    //eprintln!("cc: {:?}", cc);
    //eprintln!("v: {:?}", v);
    //eprintln!("zero_count: {}", zero_count);
    if zero_count <= k {
        println!("{}", n);
        return;
    }
    let mut max = 0;
    for i in 0..v.len() {
        let mut tmax = 0;
        let mut right;
        if v[i].0 == 0 {
            right = 2 * k + i;
        } else {
            right = 2 * k + 1 + i;
        }
        if v.len() < right {
            right = v.len();
        }
        for j in i..right {
            tmax += v[j].1;
        }
        //eprintln!("right: {}", right);
        //eprintln!("tmax: {}", tmax);
        if max < tmax {
            max = tmax;
        }
    }
    println!("{}", max);
}