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++ (GCC 9.2.1) (judge verdict: Wrong Answer)

// #include <bits/stdc++.h>
#include <algorithm>
#include <cmath>
#include <deque>
#include <iostream>
#include <iterator>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>

using namespace std;
typedef long long ll;

#define all(x) begin(x), end(x)
#define rep(i,n) for(int i=0; i<n; i++)

struct BIT {
    ll n;
    vector<ll> data;
    BIT(ll size): n(size), data(size+1, 0) {}     // コンストラクタ(1-indexed)

    void add(ll i, ll x) {
        if (i == 0) return;
        for (ll k=i; k<=n; k+=(k & -k)) data[k] += x;
    }

    ll sum(ll i) {
        ll res = 0;
        if (i == 0) return res;
        for (ll k=i; k>0; k-=(k & -k)) res += data[k];
        return res;
    }
};


int main() {
    int n, k;
    cin >> n >> k;

    vector<int> a(n);
    rep(i, n) cin >> a[i];

    if (log2(n) + 1 < k) {
        rep(i, n) cout << n << " ";
        cout << endl;
        return 0;
    }

    BIT bit0(n);
    BIT bit1(n);
    rep(_, k) {
        rep(i, n) {
            int l = max(0, i-a[i])+1; int r = min(n-1, i+a[i])+1;
            bit0.add(l, -(l-1));
            bit0.add(r+1, r);
            bit1.add(l, 1);
            bit1.add(r+1, -1);
        }
        rep(i, n) {
            a[i] = (bit0.sum(i+1) + (i+1) * bit1.sum(i+1));
            if (i > 0) a[i] -= (bit0.sum(i) + i * bit1.sum(i));
            a[i] = max(a[i], n);
        }
        bit0.data.assign(n+1, 0);
        bit1.data.assign(n+1, 0);
    }


    // vector<int> b(n, 0);
    // rep(_, k) {
    //     rep(i, n) {
    //         b[i]++;
    //         for (int d=1; d<=a[i]; d++) {
    //             if (i-d >= 0) b[i-d]++;
    //             if (i+d < n) b[i+d]++;
    //         }
    //     }
    //     rep(i, n) a[i] = max(n, b[i]);
    //     b.assign(n, 0);
    // }

    rep(i, n) cout << a[i] << " ";
    cout << endl;
    return 0;
}