Problem:
Score : 2000 points

Problem Statement

You are given a permutation P_1 ... P_N of the set {1, 2, ..., N}.

You can apply the following operation to this permutation, any number of times (possibly zero):

Choose two indices i,j (1 ≦ i < j ≦ N), such that j - i ≧ K and |P_i - P_j| = 1.
Then, swap the values of P_i and P_j.

Among all permutations that can be obtained by applying this operation to the given permutation, find the lexicographically smallest one.

Constraints

2≦N≦500,000

1≦K≦N-1

P is a permutation of the set {1, 2, ..., N}.

Input

The input is given from Standard Input in the following format:

N K
P_1 P_2 ... P_N

Output

Print the lexicographically smallest permutation that can be obtained.

Sample Input 1

4 2
4 2 3 1

Sample Output 1

2
1
4
3

One possible way to obtain the lexicographically smallest permutation is shown below:

4 2 3 1

4 1 3 2

3 1 4 2

2 1 4 3

Sample Input 2

5 1
5 4 3 2 1

Sample Output 2

1
2
3
4
5

Sample Input 3

8 3
4 5 7 8 3 1 2 6

Sample Output 3

1
2
6
7
5
3
4
8

Solution in C++14 (GCC 5.4.1) (judge verdict: Wrong Answer)

#include <iostream>
#include <cstdio>
#include <algorithm>
#include <cstring>
#include <vector>
#include <queue>
typedef long long ll;
#define Ls (u << 1)
#define Rs (u << 1 | 1)
#define inc(i) (++ (i))
#define dec(i) (-- (i))
#define Rep(i , a , b) for(int i = (a) , i##Limit = (b) ; i <= i##Limit ; inc(i))
#define rep(i , a , b) for(int i = (a) , i##Limit = (b) ; i >= i##Limit ; dec(i))
using namespace std;

const int N = 1000000 + 7;
int n , k , Ord[N] , Min[N] , Ans[N] , In[N];
vector <int> E[N];
void Update(int u , int l , int r , int Pos , int w) {
	if(l == r) {
		Min[u] = min(Min[u] , w);
		return;
	}
	int Mid = (l + r) >> 1;
	if(Mid >= Pos) Update(Ls , l , Mid , Pos , w);
	else Update(Rs , Mid + 1 , r , Pos , w);
	Min[u] = min(Min[Ls] , Min[Rs]);
}
int Query(int u , int l , int r , int L , int R) {
	if(L > R) return Min[0];
	if(L <= l && R >= r) return Min[u];
	int Mid = (l + r) >> 1 , Ret = 2147483647;
	if(Mid >= L) Ret = Query(Ls , l , Mid , L , R);
	if(Mid < R) Ret = min(Ret , Query(Rs , Mid + 1 , r , L , R));
	return Ret;
}
priority_queue <int> Q;
inline void TopSort() {
	int Sz = 0;
	Rep(i , 1 , n) if(!In[i]) Q.push(-i);
	while(!Q.empty()) {
		int u = Q.top(); Q.pop();
		Ans[-u] = inc(Sz);
		for(auto v: E[-u])
			if(!dec(In[v])) Q.push(-v);
	}
}

int main() {
	int x;
	scanf("%d%d" , &n , &k);
	memset(Min , 127 , sizeof(Min));
	Rep(i , 1 , n) scanf("%d" , &x) , Ord[x] = i;
	rep(i , n , 1) {
		int t = Query(1 , 1 , n , max(1 , Ord[i] - k + 1) , Ord[i] - 1);
		if(t != Min[0]) E[Ord[i]].push_back(Ord[t]) , inc(In[Ord[t]]);// , printf("%d %d\n" , Ord[i] , Ord[t]);
		t = Query(1 , 1 , n , Ord[i] + 1 , min(n , Ord[i] + k - 1));
		if(t != Min[0]) E[Ord[i]].push_back(Ord[t]) , inc(In[Ord[t]]);// , printf("%d %d\n" , Ord[i] , Ord[t]);
		Update(1 , 1 , n , Ord[i] , i);
	}
	TopSort();
	Rep(i , 1 , n) printf("%d\n" , Ans[i]);
	return 0;
}