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 JavaScript (node.js v5.12) (judge verdict: Runtime Error)

// inputに入力データ全体が入る
function Main(input) {
	// 1行目がinput[0], 2行目がinput[1], …に入る
    input = input.split("\n");
    // 数値の配列を作る
    const numList1 = input[0].split(' ').map(x => parseInt(x, 10));
    const N = numList1[0];
    const K = numList1[1];
    const SCharList = input[1].split(' ')[0];
  	if (SCharList.includes('0') === false) {
    	console.log(SCharList.length);
		return;
    }

    const length = SCharList.length;
    var baseC = SCharList[0];

    var cnt = 1;
    const sameCountList = [];
    for (var i = 1; i < length; i++) {
        var tempC = SCharList[i];
        if (baseC === tempC) {
            cnt++;
        } else {
            sameCountList.push(cnt);
          	baseC = tempC;
            cnt = 1;
        }
    }
  	if (baseC === tempC) {
	  	sameCountList.push(cnt);
    }
    // 最初が0の時
    if (SCharList[0] === '0') {
        // 先頭に1の個数を入れる
        sameCountList.unshift(0);
    }
    // 最後が0の時
    if (SCharList[SCharList.length - 1] === '0') {
        // 最後に1の個数を入れる
        sameCountList.push(0);
    }

    // 101の数の配列を作る
    const oneZeroOneList = [];
    for (var i = 0; i < sameCountList.length;) {
        oneZeroOneList.push([sameCountList[i], sameCountList[i + 1], sameCountList[i + 2]]);
        i += 2;
      	if (i + 2 > sameCountList.length) {
          break;
        }
    }
  
    // ここからが本番の処理
    // 足して一番大きくなる箇所を探す
    const reducer = (accumulator, currentValue) => accumulator + currentValue;
    for (var j = 0; j < K; j++) {
        var max = 0;
        var index = -1;
        for (var i = 0; i < oneZeroOneList.length; i++) {
            var array = oneZeroOneList[i];
            var sum = array.reduce(reducer);
            if (sum > max) {
                max = sum;
                index = i;
            }
        }
      	if (index === 0) {
          oneZeroOneList[index + 1][0] = max;
          oneZeroOneList.splice(index, 1);
        } else if (index !== -1) {
            oneZeroOneList[index - 1][2] = max;
            oneZeroOneList.splice(index, 1);
        }  	
    }

    // 最大値を探しに行く
    for (var i = 0; i < oneZeroOneList.length; i++) {
        var array = oneZeroOneList[i];
      	var value1 = array[0];
        var value2 = array[2];
        max = Math.max(value1, value2);

    }

    console.log(max);
}
 
Main(require("fs").readFileSync("/dev/stdin", "utf8"));