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 C# (Mono-csc 3.5.0) (judge verdict: Time Limit Exceeded)

using System;
using System.Collections.Generic;
using System.Linq;

class C
{
	static int[] Read() => Console.ReadLine().Split().Select(int.Parse).ToArray();
	static void Main()
	{
		var h = Read();
		int n = h[0], k = Math.Min(17, h[1]);
		var a = Read();

		var st = new ST(n);
		for (int c = 0; c < k; c++)
		{
			st.Clear();
			for (int i = 0; i < n; i++)
				st.Add(Math.Max(0, i - a[i]), Math.Min(n, i + a[i] + 1), 1);
			for (int i = 0; i < n; i++)
				a[i] = (int)st.Get(i);
		}
		Console.WriteLine(string.Join(" ", a));
	}
}

class ST
{
	int kMax;
	List<long[]> vs = new List<long[]> { new long[1] };
	public ST(int n)
	{
		for (int c = 1; c < n; vs.Add(new long[c <<= 1])) ;
		kMax = vs.Count - 1;
	}

	public void Clear()
	{
		for (int k = 0; k <= kMax; k++)
			Array.Clear(vs[k], 0, vs[k].Length);
	}

	(int k, int i)[] GetLevels(int i)
	{
		var r = new List<(int, int)>();
		for (int k = kMax; k >= 0; --k, i >>= 1) r.Add((k, i));
		return r.ToArray();
	}

	(int k, int i)[] GetRange(int minIn, int maxEx)
	{
		var r = new List<(int, int)>();
		for (int k = kMax, f = 1; k >= 0 && minIn < maxEx; --k, f <<= 1)
		{
			if ((minIn & f) != 0) r.Add((k, (minIn += f) / f - 1));
			if ((maxEx & f) != 0) r.Add((k, (maxEx -= f) / f));
		}
		return r.ToArray();
	}

	public void Add(int minIn, int maxEx, long v)
	{
		foreach (var (k, i) in GetRange(minIn, maxEx)) vs[k][i] += v;
	}

	public long Get(int i) => GetLevels(i).Sum(x => vs[x.k][x.i]);
}