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 Java (OpenJDK 11.0.6) (judge verdict: Accepted)

import java.util.Arrays;
import java.util.Scanner;

public class Main {
	static class FenwickTree {
	    int n;
	    long x[];
	    public FenwickTree(int N) {
	    	this.n = N;
	    	x = new long[N + 1] ;
		}
	    int size()  { return n; }
	    long sum(int r) {
	        long S = 0;
	        for (r = r - 1; r >= 0; r = (r & (r + 1)) - 1) S += x[r];
	        return S;
	    }
	    long sum(int l, int r)  { return sum(r) - sum(l); }
	    void add(int k, long a) {
	        for (; k < n; k |= k + 1) {
	        	x[k] += a;
	        }
	    }
	    void set(int k, long a) { add(k, a - sum(k, k + 1)); }
	};
	static void solve(int A[] , int K){
		int N = A.length;
		FenwickTree ft = new FenwickTree(N);
		for(int i = 0 ; i < N ; ++i){
			int a = A[i];
			if(a == 0){
				continue;
			}
			ft.add(i,   a);
			ft.add(i + 1, - a);
		}
		for(int i = 0 ; i < K ; ++i){
			FenwickTree L = new FenwickTree(N);
			for(int j = 0 ; j < A.length ; ++j){
				int a = (int)ft.sum(0, j + 1);
				int l = j - a;
				int r = j + a;
				if(l < 0){
					l = 0;
				}
				if(r >= N){
					r = N - 1;
				}
				L.add(l, 1);
				L.add(r + 1, -1);
			}
			ft = L;
			boolean f = true;
			for(int j = 0 ; j < A.length ; ++j){
				int a = (int)ft.sum(0, j + 1);
				if(a != N){
					f = false;
					break;
				}
			}
			if(f){
				break;
			}
		}
		StringBuilder sb = new StringBuilder();
		for(int j = 0 ; j < A.length ; ++j){
			if(sb.length() > 0){
				sb.append(' ');
			}
			int a = (int)ft.sum(0, j + 1);
			sb.append(a);
		}
		System.out.println(sb.toString());
	}
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		int N = sc.nextInt();
		int K = sc.nextInt();
		int A[] = new int[N];
		for(int i = 0 ; i < N ; ++i){
			A[i] = sc.nextInt();
		}
		solve(A, K);
	}
}