output_description: 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
      
  
  * * *
input_description: Input is given from Standard Input in the following format:
  
      
      
      N K
      A_1 A_2 \ldots A_N
attempt: import sys
  
  read = sys.stdin.buffer.read
  readline = sys.stdin.buffer.readline
  readlines = sys.stdin.buffer.readlines
  n, k = map(int, readline().split())
  A = list(map(int, readline().split()))
  
  
  class SegmentTree:
      def __init__(self, n, ele, segfun):
          #####単位元######要設定0or1orinf
          self.ide_ele = ele
          self.segfun = segfun
          ####################
          self.n = n
          self.N0 = 1 << n.bit_length()
          self.data = [self.ide_ele] * (self.N0 * 2)
  
      def update_add(self, l, r, val):
          l += self.N0
          r += self.N0
          while l < r:
              if l & 1:
                  self.data[l] += val
                  l += 1
              if r & 1:
                  self.data[r - 1] += val
                  r -= 1
              l //= 2
              r //= 2
  
      def update(self, l, r, val):
          l += self.N0
          r += self.N0
          while l < r:
              if l & 1:
                  self.data[l] = self.segfun(self.data[l], val)
                  l += 1
              if r & 1:
                  self.data[r - 1] = self.segfun(self.data[r - 1], val)
                  r -= 1
              l //= 2
              r //= 2
  
      def query(self, i):
          i += len(self.data) // 2
          ret = self.data[i]
          while i > 0:
              i //= 2
              ret = self.segfun(ret, self.data[i])
          return ret
  
  
  for i in range(k):
      m = n
      S = SegmentTree(n, 0, lambda a, b: a + b)
      for j in range(n):
          q = A[j]
          m = min(m, q)
          S.update_add(max(1, j - q + 1), min(n + 1, j + q + 2), 1)
      if i < k - 1 and m >= n - 1:
          A = [n] * n
          break
      for l in range(n):
          p = S.query(l + 1)
          A[l] = p
  
  print(*A)
  
problem_description: 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.
samples: [{"input": "5 1\n    1 0 0 1 0", "output": "1 2 2 1 2 \n    \n\nInitially, only Bulb 1 illuminates coordinate 1, so the intensity of Bulb 1\nbecomes 1 after the operation. Similarly, the bulbs initially illuminating\ncoordinate 2 are Bulb 1 and 2, so the intensity of Bulb 2 becomes 2.\n\n* * *"}, {"input": "5 2\n    1 0 0 1 0", "output": "3 3 4 4 3"}]