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 Haskell (GHC 7.10.3) (judge verdict: Wrong Answer)

-- ABC124 D problem
import Control.Monad
import qualified Data.Text as T

-- conversion from String to Int
toInt :: String -> Int
toInt x = read x :: Int

-- obtain [Int] from I/O
getInts :: IO [Int]
getInts = do
  x <- getLine
  let y = (map $ toInt) $ words x
  return y

subf :: Char -> Int
subf '0' = 0
subf '1' = 1

swpoints :: String -> [[Int]]
swpoints [c] = [[0], [(subf c)]]
swpoints (x:(x1:xs)) =
  if x /= x1 then [(head (swpoints (x1:xs)))++[length (x1:xs)], (last (swpoints (x1:xs)))++[subf x1]]
  else (swpoints (x1:xs))

shift :: [Int] -> Int -> Int -> [Int]
shift x n 0 = x
shift (x:xs) n sh = shift (xs ++ [n]) n (sh-1)

gains :: [Int] -> [Int] -> [Int] -> [Int] -> [Int]
gains [] [] [] [] = []
gains (p:ps) (p1:p1s) (p2:p2s) (q:qs) =
  case q of
    0 -> [p1-p] ++ (gains ps p1s p2s qs)
    1 -> [p2-p] ++ (gains ps p1s p2s qs)

maxi :: [Int] -> Int
maxi [] = 0
maxi (x:xs) = max x (maxi xs)

-- main function
main :: IO ()
main = do
  nk <- getInts
  let n = head nk
  let k = last nk
  s <- getLine
  let is = swpoints s
  let p = head is
  let q = last is
  let p1 = shift p n (2*k)
  let p2 = shift p n (2*k+1)
  print (maxi (gains p p1 p2 q))