Problem:
Score : 500 points

Problem Statement

We have N bulbs arranged on a number line, numbered 1 to N from left to right.
Bulb i is at coordinate i.

Each bulb has a non-negative integer parameter called intensity.
When there is a bulb of intensity d at coordinate x, the bulb illuminates the segment from coordinate x-d-0.5 to x+d+0.5.
Initially, the intensity of Bulb i is A_i. We will now do the following operation K times in a row:

For each integer i between 1 and N (inclusive), let B_i be the number of bulbs illuminating coordinate i. Then, change the intensity of each bulb i to B_i.

Find the intensity of each bulb after the K operations.

Constraints

1 \leq N \leq 2 \times 10^5

1 \leq K \leq 2 \times 10^5

0 \leq A_i \leq N

Input

Input is given from Standard Input in the following format:

N K
A_1 A_2 \ldots A_N

Output

Print the intensity A{'}_i of each bulb i after the K operations to Standard Output in the following format:

A{'}_1 A{'}_2 \ldots A{'}_N

Sample Input 1

5 1
1 0 0 1 0

Sample Output 1

1 2 2 1 2

Initially, only Bulb 1 illuminates coordinate 1, so the intensity of Bulb 1 becomes 1 after the operation.
Similarly, the bulbs initially illuminating coordinate 2 are Bulb 1 and 2, so the intensity of Bulb 2 becomes 2.

Sample Input 2

5 2
1 0 0 1 0

Sample Output 2

3 3 4 4 3

Solution in Scala (2.13.1) (judge verdict: Wrong Answer)

// TLE: 処理時間がかかりすぎている。累積和とかimos法というのがあるらしい
object Main extends App {
  val inputs: Seq[String] = scala.io.Source.stdin.getLines().toList
  
  val nums = inputs(0).split(" ").map(_.toInt)
  val n = nums(0)
  val k = nums(1)
  val ramps = inputs(1).split(" ").map(_.toInt)


  println(solve(k, ramps))

  private def solve(k: Int, ramps: Seq[Int]): String = {
    val size = ramps.size
    if(k > 500) {
      return Seq.fill(size)(size).mkString(" ")
    }

    var currentPower = scala.collection.mutable.ArrayBuffer.empty[Int]
    ramps.foreach{v =>
        currentPower.append(v)
    }

    (1 to k).foreach{ _ =>
      val nextPower = scala.collection.mutable.ArrayBuffer.fill(ramps.size)(0)

      (0 until size).foreach { i =>
        val light = currentPower(i)
        val range = Range.inclusive(Math.max(0, i - light), Math.min(i + light, size - 1), 1)
        println(range.toString)

        range.foreach { j =>
          nextPower.update(j, nextPower(j) + 1)
        }
      }
      currentPower = nextPower.clone()
      println(s"""now => ${currentPower}""")
    }
    currentPower.toSeq.mkString(" ")
  }
}