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 Haskell (GHC 8.8.3) (judge verdict: Time Limit Exceeded)

import qualified Data.ByteString.Char8 as BS
import Data.Char
import Data.List
import Data.Array

main = do
  li <- BS.getLine
  let [n,k] = unfoldr (BS.readInt . BS.dropWhile isSpace) li
  li <- BS.getLine
  let as = unfoldr (BS.readInt . BS.dropWhile isSpace) li
  let ans = compute n k as
  putStrLn $ unwords $ map show ans

{- いもす法
立ち上がりと立下りを一つの配列に累積し、それをなぞることで各ポイントの値を一気に取りだす
-}
compute :: Int -> Int -> [Int] -> [Int]
compute n k as = iterate (step n) as !! k

step :: Int -> [Int] -> [Int]
step n as = scanl1 (+) $ init $ elems $ accumArray (+) 0 (1,n1) imar
  where
    n1 = succ n
    imar = [p | (i,a) <- zip [1..] as, p <- [(max 1 (i-a),1), (min n1 (i+a+1),-1)]]

{- naive code : TLE
compute n k as = elems $ iterate (step n) (listArray (1,n) as) !! k
step n ar = accumArray (+) 0 (1,n) [ (j,1) | i <- [1..n], j <- [max 1 (i - ar ! i)..min n (i + ar ! i)] ]
-}