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)

{-# LANGUAGE BangPatterns #-}
import Control.Monad
import Data.Maybe
import Debug.Trace
import Data.List
import qualified Data.Map.Strict as Map
import qualified Data.IntMap.Strict as IntMap
import qualified Data.Set as Set
import qualified Data.IntSet as IntSet
import Data.Functor
import Data.Array
-- import Data.Array.Unboxed
import Control.Monad.ST
import Data.Array.ST
import Data.Char

main :: IO ()
main = do
  (n:k:_) <- fmap (map read . words) getLine :: IO [Int]
  s <- getLine
  print $ solve n k $ map digitToInt s

-- solve :: Int -> Int -> [Int] -> Int
solve n k s = traceShow (reverse code) $ calck code $ drop (2 * k) code
  where
    code = encode s
    encode :: [Int] -> [(Int, Int)]
    encode = go []
      where
        go :: [(Int, Int)] -> [Int] -> [(Int, Int)]
        go [] (s:ss) = go [(s, 1), (abs (s-1), 0)] ss
        go t [] = let (s, n) = head t in ((abs (s-1), n):t)
        go ((t, n):ts) (s:ss)
         | t == s = go ((s, n + 1):ts) ss
         | otherwise = go ((s, n + 1):(t, n):ts) ss

    calck :: [(Int, Int)] -> [(Int, Int)] -> [Int]
    calck _ [] = [0]
    calck (c:cs) (b:bs)
      | s == 1 = if null bs 
                 then [nc - nb]
                 else (nc - nbb):(calck cs bs)
      | s == 0 = (nc - nb):(calck cs bs)
      where
        (s, nc) = c
        (_, nb) = b
        (_, nbb) = head bs