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 Java8 (OpenJDK 1.8.0) (judge verdict: Wrong Answer)

import java.io.BufferedReader;
import java.io.Closeable;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.StringTokenizer;

public class Main {
	
	public static void main(String[] args) throws IOException {
		try(final Scanner sc = new Scanner(System.in)){
			final int N = sc.nextInt();
			final int K = sc.nextInt();
			
			final char[] chs = sc.next().toCharArray();
			
			ArrayList<Integer> list = new ArrayList<Integer>();
			ArrayList<Boolean> isOne = new ArrayList<Boolean>();
			{
				int prev_value = -1;
				int cnt = 0;
				for(int i = 0; i < chs.length; i++) {
					if(prev_value < 0) {
						prev_value = chs[i];
						cnt = 1;
					}else if(prev_value != chs[i]) {
						list.add(cnt);
						isOne.add(prev_value != '0');
						prev_value = chs[i];
						cnt = 1;
					}else {
						cnt += 1;
					}
				}
				if(cnt != 0) { list.add(cnt); isOne.add(prev_value != '0'); cnt = 0; }
			}
			//System.out.println(list);
			
			int answer = 0;
			{// 111 ->
				int curr = 0;
				for(int i = 0; i < Math.min(2 * K + 1, list.size()); i++) { curr += list.get(i); }
			
				answer = Math.max(answer, isOne.get(0) ? curr : 0);
				for(int i = 1; i < (list.size() - (2 * K)); i++) {
					curr -= list.get(i - 1);
					curr += list.get(i + 2 * K);
					//System.out.printf("%s [%d, %d) = %d\n", list, i, i + 2 * K + 1, curr, list.size());
					if(isOne.get(i)) { answer = Math.max(answer, curr); }
				}
			}
			{ // 000 ->
				int curr = 0;
				for(int i = 0; i < Math.min(2 * K, list.size()); i++) { curr += list.get(i); }
				//System.out.println(curr);
				
				answer = Math.max(answer, !isOne.get(0) ? curr : 0);
				for(int i = 1; i <= (list.size() - 2 * K); i++) {
					curr -= list.get(i - 1);
					curr += list.get(i + (2 * K - 1));
					//System.out.printf("%s [%d, %d) = %d\n", list, i, i + 2 * K, curr, list.size());
					if(!isOne.get(i)) { answer = Math.max(answer, curr); }
				}
			}
			
			System.out.println(answer);
		}
	}

	public static class Scanner implements Closeable {
		private BufferedReader br;
		private StringTokenizer tok;

		public Scanner(InputStream is) throws IOException {
			br = new BufferedReader(new InputStreamReader(is));
		}

		private void getLine() throws IOException {
			while(!hasNext()){
				tok = new StringTokenizer(br.readLine());
			}
		}

		private boolean hasNext() {
			return tok != null && tok.hasMoreTokens();
		}

		public String next() throws IOException {
			getLine();
			return tok.nextToken();
		}

		public int nextInt() throws IOException {
			return Integer.parseInt(next());
		}

		public long nextLong() throws IOException {
			return Long.parseLong(next());
		}

		public double nextDouble() throws IOException {
			return Double.parseDouble(next());
		}

		public int[] nextIntArray(int n) throws IOException {
			final int[] ret = new int[n];
			for(int i = 0; i < n; i++){
				ret[i] = this.nextInt();
			}
			return ret;
		}

		public long[] nextLongArray(int n) throws IOException {
			final long[] ret = new long[n];
			for(int i = 0; i < n; i++){
				ret[i] = this.nextLong();
			}
			return ret;
		}

		public void close() throws IOException {
			br.close();
		}
	}
}