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

[AGC001F] Wide Swap

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

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

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

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

在 \(P\) 上，满足 \(P_i=\max\limits_{|i-j|<k} 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;
}