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 Scala (2.11.7) (judge verdict: Wrong Answer)

object Main {
  def main(args: Array[String]) {
    if (sys.env.getOrElse("TEST", "") == "1") {
      println(test());
    } else {
      val input = io.Source.stdin.getLines().mkString("\n");
      println(solve(input).trim());
    }
  }
  type Chunk = (Char, Int)

  def solve(input: String): String = {
    val arr = input.split("\n")
    val tmp = arr(0).split(" ").map(_.toInt)
    val k = tmp(1)
    val t = arr(1).toCharArray.foldLeft((List.empty[Int], List.empty[List[Int]]))((acc, c) => {
      val (now, arr) = acc
      if (!now.isEmpty && now(0) == c) {
        (c::now, arr)
      } else {
        (List(c), now::arr)
      }
    })
    val lens = if (arr(1).charAt(arr(1).length-1) == '1') {
      (t._1::t._2).map(_.length)
    } else {
      0 :: (t._1::t._2).map(_.length)
    }
    val chunk = lens.zipWithIndex.foldLeft((0, List.empty[Int]))((acc, t) => {
      val (c, arr) = acc
      val (count, index) = t
      if (index % 2 == 0) (count, arr) else (0, (c+count)::arr)
    })._2
    val max = chunk.zipWithIndex.foldLeft(chunk.take(k).sum)((max, t) => {
      val (count, index) = t
      if (index + k >= chunk.length) max
      else {
        val tmp = max - chunk(index) + chunk(index + k)
        if (tmp > max) tmp else max
      }
    })
    return max.toString
  }

  val tests = List(
    """5 1
      |00010""".stripMargin -> "4",
    """14 2
      |11101010110011""".stripMargin -> "8",
    """1 1
      |1""".stripMargin -> "1");

  def test(): String = {
    return tests.map { case (i, o) => (i.trim(), o.trim()) }
      .zipWithIndex.map {
      case ((input, outputExpect), i) => {
        val output = solve(input).trim();
        s"test${i + 1}:" + (if (output == outputExpect) {
          "Passed"
        } else {
          s"Failed\nexpect:\n${outputExpect}\noutput:\n${output}"
        })
      }
    }
      .mkString("\n");
  }
}