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# (.NET Core 3.1.201) (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 = h[1];
		var a = Read();

		var next = true;
		for (int c = 0; c < k && next; c++)
		{
			next = false;
			var st = new ST(n + 1);
			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++)
			{
				var v = (int)st.Get(i);
				if (a[i] != v)
				{
					a[i] = v;
					next = true;
				}
			}
		}
		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;
	}

	void ForLevels(int i, Action<(int k, int i)> action)
	{
		for (int k = kMax; k >= 0; --k, i >>= 1) action((k, i));
	}

	void ForRange(int minIn, int maxEx, Action<(int k, int i)> action)
	{
		for (int k = kMax, f = 1; k >= 0 && minIn < maxEx; --k, f <<= 1)
		{
			if ((minIn & f) != 0) action((k, (minIn += f) / f - 1));
			if ((maxEx & f) != 0) action((k, (maxEx -= f) / f));
		}
	}

	public void Add(int minIn, int maxEx, long v)
	{
		ForRange(minIn, maxEx, x => vs[x.k][x.i] += v);
	}

	public long Get(int i)
	{
		var sum = 0L;
		ForLevels(i, x => sum += vs[x.k][x.i]);
		return sum;
	}
}