W i d e s w a p Wide\ swap Wide swap
最 初 想 法 \color{blue}{最初想法} 最初想法
对于 A i < A j A_i < A_j Ai<Aj 的点对 i , j i, j i,j, 不会出现 A i A_i Ai 与 A j A_j Aj 交换后, A i A_i Ai 在 A j A_j Aj 在 后面的情况 .
正 解 部 分 \color{red}{正解部分} 正解部分
新建一个数组
B
[
]
B[]
B[], 使得
B
[
A
[
i
]
]
=
i
B[A[i]] = i
B[A[i]]=i,
则要求
A
[
]
A[]
A[] 排列字典序最小的问题 就转化成了 使要求
B
[
]
B[]
B[] 字典序最小的问题,
且交换条件为:
- 位置相邻 .
- 权值差大于等于 K K K .
考虑两个元素
B
i
,
B
j
B_i, B_j
Bi,Bj, 若
i
<
j
i < j
i<j,
B
i
−
B
j
<
K
B_i - B_j < K
Bi−Bj<K, 则
i
i
i 与
j
j
j 的相对位置不可改变,
此时若
i
i
i 向
j
j
j 连边, 建图后可以使用 拓扑排序 可以确定最小字典序数列 .
但是这样建图的时空复杂度是 O ( N 2 ) O(N^2) O(N2) 的, 需要加以优化 .
注意到在拓扑排序中, 当 a → b a \rightarrow b a→b, b → c b \rightarrow c b→c, 则 a → c a \rightarrow c a→c 是无意义的, 从这方面来优化 .
具
体
来
说
具体来说
具体来说:
从后往前遍历, 设当前位置为
i
i
i, 则
B
[
i
]
B[i]
B[i] 向 值属于
(
B
[
i
]
−
K
,
B
[
i
]
)
∪
(
B
[
i
]
,
B
[
i
]
+
K
)
(B[i]-K, B[i])∪(B[i], B[i]+K)
(B[i]−K,B[i])∪(B[i],B[i]+K) 中 存在的 最小编号的
B
[
j
]
B[j]
B[j] 连边 .
实 现 部 分 \color{red}{实现部分} 实现部分
- 注意线段树中的节点是以 B [ ] B[] B[]值为下标, B [ ] B[] B[]下标为值的
#include<bits/stdc++.h>
#define reg register
int read(){
char c;
int s = 0, flag = 1;
while((c=getchar()) && !isdigit(c))
if(c == '-'){ flag = -1, c = getchar(); break ; }
while(isdigit(c)) s = s*10 + c-'0', c = getchar();
return s * flag;
}
const int maxn = 500005;
const int inf = 0x3f3f3f3f;
int N;
int K;
int num0;
int A[maxn];
int B[maxn];
int In_d[maxn];
int head[maxn];
int top_A[maxn];
struct Segment_Tree{
struct Node{ int l, r, min_v; } T[maxn<<2];
void Build(int k, int l, int r){
T[k].l = l, T[k].r = r, T[k].min_v = inf;
if(l == r) return ;
int mid = l+r >> 1;
Build(k<<1, l, mid), Build(k<<1|1, mid+1, r);
}
int Query(int k, const int &ql, const int &qr){
int l = T[k].l, r = T[k].r;
if(ql <= l && r <= qr) return T[k].min_v;
int mid = l+r >> 1;
int s = inf;
if(ql <= mid) s = Query(k<<1, ql, qr);
if(qr > mid) s = std::min(s, Query(k<<1|1, ql, qr));
return s;
}
void Insert(int k, int aim, int v){
int l = T[k].l, r = T[k].r;
if(l == r){ T[k].min_v = v; return ; }
int mid = l+r >> 1;
if(aim <= mid) Insert(k<<1, aim, v);
else Insert(k<<1|1, aim, v);
T[k].min_v = std::min(T[k<<1].min_v, T[k<<1|1].min_v);
}
} Seg_t;
struct Edge{ int nxt, to; } edge[maxn << 1];
void Add(int from, int to){
edge[++ num0] = (Edge){ head[from], to };
head[from] = num0;
}
void Link(){
Seg_t.Build(1, 1, N);
for(reg int i = N; i >= 1; i --){
int res = Seg_t.Query(1, std::max(1, B[i]-K+1), B[i]);
if(res <= N) Add(B[i], B[res]), In_d[B[res]] ++;
res = Seg_t.Query(1, B[i], std::min(N, B[i]+K-1));
if(res <= N) Add(B[i], B[res]), In_d[B[res]] ++;
Seg_t.Insert(1, B[i], i);
}
}
void Topsort(){
std::priority_queue <int> Q;
for(reg int i = 1; i <= N; i ++) if(!In_d[i]) Q.push(-i);
int cnt = 0;
while(!Q.empty()){
int ft = -Q.top(); Q.pop();
top_A[++ cnt] = ft;
for(reg int i = head[ft]; i; i = edge[i].nxt){
int to = edge[i].to;
if((-- In_d[to]) == 0) Q.push(-to);
}
}
}
int main(){
N = read(), K = read();
for(reg int i = 1; i <= N; i ++) A[i] = read(), B[A[i]] = i;
Link(); Topsort();
for(reg int i = 1; i <= N; i ++) A[top_A[i]] = i;
for(reg int i = 1; i <= N; i ++) printf("%d\n", A[i]);
return 0;
}