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: Wrong Answer)

use std::io::prelude::*;
use std::str::FromStr;

fn main() {
    let stdin_ = std::io::stdin();
    let stdout_ = std::io::stdout();
    let mut stdin = stdin_.lock();
    let mut stdout = stdout_.lock();

    let mut buffer = String::new();
    stdin.read_line(&mut buffer).unwrap();
    let v = buffer
        .split_whitespace()
        .map(|s| usize::from_str(s).unwrap())
        .collect::<Vec<_>>();
    let n = v[0];
    let k = v[1];
    buffer.clear();
    stdin.read_line(&mut buffer).unwrap();
    let s = buffer.trim().chars().collect::<Vec<char>>();

    let mut nums = Vec::<u64>::new();
    let mut now = 1;
    let mut cnt = 0;
    for i in 0..n {
        if s[i] as u8 == now + '0' as u8 {
            cnt += 1;
        } else {
            nums.push(cnt);
            now = 1 - now;
            cnt = 1;
        }
    }
    if cnt > 0 {
        nums.push(cnt);
    }
    if nums.len() % 2 == 0 {
        nums.push(0);
    }

    let add = 2 * k + 1;
    let mut ans = 0;
    let mut left = 0;
    let mut right = 0;
    let mut tmp = 0;

    println!("{:?}", nums);
    for i in 0..nums.len() {
        if i % 2 == 1 {
            continue;
        }

        let next_left = i;
        let next_right = std::cmp::min(i + add, nums.len());

        loop {
            if next_left <= left {
                break;
            }

            tmp -= nums[left];
            left += 1;
        }

        loop {
            if next_right <= right {
                break;
            }

            tmp += nums[right];
            right += 1;
        }

        ans = std::cmp::max(ans, tmp);
    }

    write!(stdout, "{}\n", ans).unwrap();
}