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 Julia (0.5.0) (judge verdict: Wrong Answer)

# Julia 1.0
# n, k = [parse(Int, x) for x in split(readline())]
# str = readline()
n, k = [parse(Int, x) for x in split(readline() |> chomp, " ")]
str = readline() |> chomp

xs = zeros(Int, n)
for (i, s) in enumerate(str)
    xs[i] = parse(Int, s)
end

# Julia 1.0
xor(x::Bool, y::Bool) = (x != y)
xor(x::Int, y::Int) = xor(Bool(x), Bool(y))

ys = vcat(1, xs)
flip = zeros(Int, n)
for i = 1:n
    flip[i] = xor(ys[i], ys[i+1])
end

flippoints = Int[]
for i = 1:n
    if flip[i] == 1
        push!(flippoints, i)
    end
end

# println(flip)
# println(flippoints)

values = Int[]

fn = length(flippoints)
i = 1
while i <= fn
    b = false
    left0 = 1
    if 1 <= i-1
        left0 = min(flippoints[i-1] + 1, flippoints[i] - 1)
    end
    left1 = flippoints[i]
    right1 = if fn % 2 == 0
        flippoints[end]
    else
        fn
    end
    if i+2k-1 <= fn
        right1 = flippoints[i-1+2k]
    end
    right0 = n
    if i+2k <= fn
        right0 = flippoints[i+2k] - 1
    else
        b = true
    end
    push!(values, right0 - left0 + 1)
    # println("l0, l1, r1, l0 = ", [left0, left1, right1, right0])
    # println(values)
    if b
        break
    end
    i += 2
end

if isempty(values)
    print(n)
else
    print(max(values...))
end