[AGC001F] Wide Swap （trick+拓扑排序+线段树好题）

[AGC001F] Wide Swap

trick+拓扑排序+线段树好题

看到题目的操作，显然是复杂、不好的。为什么？交换操作是无序的，我们不知道交换后对各个部分的影响，难以分析。这时候我们注意到 $|P_i-P_j|=1$ 的性质非常特殊，考虑从这里入手。

如果以值域为系，那么会发现排列中的每个下标的交换在值域中是连续的。具体的说，考虑 $P$ 的逆置换 $Q$，$Q_{p_i}=i$，那么操作也将完全相反：在 $Q$ 序列中，若 $|Q_i-Q_{\pm 1}|\ge K$，那么 $i$ 和 $\pm 1$ 可以交换。

这样有什么好处？首先相邻交换显然性质更多，其次 如果让 $Q$ 从小到大每一个数的位置尽可能靠前时 $K$ 的字典序也最小（感性理解，我们每次让 $Q_1$ 的值尽量小，那么在 $P$ 上 $1$ 的位置就更靠前，以此类推）。继续观察相邻交换，这时候我们可以想到什么时候无法操作，也就是相邻两个数的差 $<K$，这时候无法交换，继续扩大这个性质，那么就有：对于 $i<j$，若 $|Q_i-Q_j|<K$，那么无论如何交换，永远有 $i<j$。也就是题目中的条件就转化为满足交换后若干对相对位置不变。相对位置不变，不难想到 $DAG$。我们给这些限制条件连 $i\to j$，每个点点权是 $Q_i$。显然这样构成的图是 $DAG$，那么就转化为求从小到大每一个数的位置尽可能靠前的拓扑排序了。

这是一个经典的问题，一般的实现方法：建 $DAG$ 的反图跑拓扑排序，每次把最大的点放到拓扑序的末尾并拓展新的点。不同于求字典序最小，直接正着做就可以。

这样子就有了本题的朴素做法，跑 $Q$ 序列的拓扑排序，最后逆过来求出 $P$ 即可。由于连边多，复杂度 $O(nk)$。

考虑不去建出这张图，用其他数据结构维护上述过程。我们发现，在 $Q$ 上考虑连边是不优的，因为连边不连续，但是我们连边时发现 $Q$ 的值构成的集合是连续一段区间，也就是回到 $P$，下标是连续的！所以考虑又回到 $P$ 序列考虑连边，那么就有：对于 $P_i<P_j$，若 $|i-j|<K$，那么连边 $(P_i,P_j)$。这样子连边是等价的，值得注意的是，需要求的 $DAG$ 中每个点的权值为 $i$。

考虑拓扑排序的过程，需要找到当前时刻出度为 $0$ 的点。在 $Q$ 上，这样的点满足 $i=\underset{|Q_i-Q_j|<K}{max}j$。

在 $P$ 上，满足 $P_i=\underset{|i-j|<k}{max}{P}_j$。这样的点不存在后继。

$P$ 中的形式显然可以用数据结构维护。考虑线段树维护区间最大值下标，那么将这个点放入堆中就看作将 $P_i=-inf$。此时会拓展新的点，一定在 $(i-k+1,i)$ 和 $(i,i+k-1)$ 内，且新的点 $x$ 满足 $P_x$ 为其中一个区间的最大值，然后推入堆中时要判断是否出度为 $0$，不为 $0$ 那么没有新的点，不用入队。

将 $Q$ 转成 $P$ 可以一步到位，具体看代码。至此这题就结束了。复杂度 $O(n\log n)$。

#include <iostream>
#include <vector>
#include <cstdio>
#include <cmath>
#include <string>
#include <array>
#include <map>
#include <set>
#include <queue>
#include <stack>
#include <algorithm>
#include <cstdlib>
#include <bitset>
#define pii std::pair<int, int>
#define fi first
#define se second
#define pb push_back

typedef long long i64;
const i64 iinf = 0x3f3f3f3f, linf = 0x3f3f3f3f3f3f3f3f;
const int N = 5e5 + 10;
int n, k, m;
int a[N], id[N], ans[N], vis[N];
struct seg {
	int v;
} t[N << 2];
void pushup(int u) {
	if(a[t[u << 1].v] > a[t[u << 1 | 1].v]) {
		t[u].v = t[u << 1].v;
	} else {
		t[u].v = t[u << 1 | 1].v;
	}
}
void build(int u, int l, int r) {
	if(l == r) {
		t[u].v = l;
		return;
	}
	int mid = (l + r) >> 1;
	build(u << 1, l, mid), build(u << 1 | 1, mid + 1, r);
	pushup(u);
}
int qry(int u, int l, int r, int L, int R) {
	if(r < l || !L || !R) return 0;
	if(L <= l && r <= R) return t[u].v;
	int mid = (l + r) >> 1;
	if(L > mid) return qry(u << 1 | 1, mid + 1, r, L, R);
	if(R <= mid) return qry(u << 1, l, mid, L, R);
	int ls = qry(u << 1, l, mid, L, R), rs = qry(u << 1 | 1, mid + 1, r, L, R);
	return a[ls] > a[rs] ? ls : rs;
}
void upd(int u, int l, int r, int x) {
	if(l == r) {
		t[u].v = 0;
		return;
	}
	int mid = (l + r) >> 1;
	if(x <= mid) upd(u << 1, l, mid, x);
	else upd(u << 1 | 1, mid + 1, r, x);
	pushup(u);
}
std::priority_queue<int> q;
void add(int u) {
	if(vis[u]) return;
	int l = std::max(1, u - k + 1), r = std::min(n, u + k - 1);
	if(qry(1, 1, n, l, r) == u) {
		q.push(u);
		vis[u] = 1;
	}
}
void Solve() {
	std::cin >> n >> k;
	for(int i = 1; i <= n; i++) {
		std::cin >> a[i];
	}
	a[0] = -iinf;
	build(1, 1, n);
	for(int i = 1; i <= n; i++) {
		add(i);
	}
	for(int i = n; i >= 1; i--) {
		int u = q.top(); q.pop();
		ans[u] = i; //逆置换回来
		upd(1, 1, n, u);

		int l = std::max(1, u - k + 1), r = std::min(n, u + k - 1);
		int v = qry(1, 1, n, l, u);
		if(v) add(v);
		v = qry(1, 1, n, u, r);
		if(v) add(v);
	}
	for(int i = 1; i <= n; i++) std::cout << ans[i] << "\n";
}
int main() {
    std::ios::sync_with_stdio(false);
    std::cin.tie(nullptr);
    
	Solve();

	return 0;
}