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 Ruby (2.3.3) (judge verdict: Time Limit Exceeded)

N,K = (gets).split(" ").map { |i| i.to_i }
#N = 100000
#K = 100000
inputs = gets
#inputs = "10"*(N/2)
ss = (inputs.delete("\n")).chars.map { |s| s.to_i }
#p ss

# 処理をわかりやすくするために前後に１を入れる
ss.insert(0, 1)
ss.push(1)
#p ss

# マップ化する
$map = []
def map_first(ss)
    $map[0] = []
    n = 0
    hs = 0
    st = 0
    st_p = 1
    f = false
    ss.each_with_index do |s,i|
        next if i==0
        if s == 1 then # hand stand
            if f then
                $map[0][n] = [hs,st]
                n = n + 1
                st = 0
                hs = 0
            end
            f = false
            hs = hs + 1
        else
            if not f then
                st_p = i
            end
            f = true
            st = st + 1
        end
    end
    $map[0][n] = [hs-1,st]
    #p $map[0]
    return n
end

map_first(ss)

# くっつけるとか考えないでひたすら計算する動的計画法
## DPする範囲はピラミッド状に収束するので、それを見越して計算範囲を限定する
kk = $map[0].length - K
kk = 1 if kk < 1
isEnd = false
1.upto(K) do |i|
    $map[i] = [$map[i-1][0]]
    kk.times do |j|
    #($map[0].length-i).times do |j|
        if (i+j)>=$map[0].length then
            # 頂点についてしまったということなので抜ける
            $map[K] = $map[i]
            isEnd = true
            break
        end
        $map[i][j] = [$map[i-1][j][0] + $map[i-1][j][1] + $map[0][i+j][0], $map[0][i+j][1]]
    end
    break if isEnd
    #p $map[i]
end

res = $map[K].map {|m| m[0]}
#p res
puts res.max