[CSP2019] 树上的数

题意

给定一个大小为 $n$ 的树，它共有 $n$ 个结点与 $n-1$ 条边，结点从 $1\sim n$ 编号。初始时每个结点上都有一个 $1\sim n$ 的数字，且每个 $1\sim n$ 的数字都只在恰好一个结点上出现。

接下来你需要进行恰好 $n-1$ 次删边操作，每次操作你需要选一条未被删去的边，此时这条边所连接的两个结点上的数字将会交换，然后这条边将被删去。

$n-1$ 次操作过后，所有的边都将被删去。此时，按数字从小到大的顺序，将数字 $1\sim n$ 所在的结点编号依次排列，就得到一个结点编号的排列 $P_i$。现在请你求出，在最优操作方案下能得到的字典序最小的 $P_i$。

数据范围：$1\le T\le 10,1\le n\le 2000$。

题解

我们考虑贪心，从小到大枚举 $n$ 个数，假设枚举到第 $k$ 个数（此时已经确定 $p_{1\sim k-1}$），找到编号最小的节点 $u$，让 $k$ 去 $u$，并保证存在一种方案能够使 $p_{1\sim k}$ 合法。

接下来我们需要考虑怎么保证这件事情。我们从每条边被删去的时间考虑，考虑下述例子：

如果②去点2，我们能够知道：$(1,4)$ 是 $(1,3),(1,4)$ 中最先被删的（不然②就去别的地方了比如3），对于 4 的邻接表 { ( 4 , 1 ) , ( 4 , 2 ) , ( 4 , 5 ) } \{(4,1),(4,2),(4,5)\} {(4,1),(4,2),(4,5)} 这三条边，$(4,1)$ 被删后**马上跟着 **$(4,2)$ （不然②就去别的地方了比如5）。如果 2 的邻接表不止 $(2,4)$ 一个，我们还能确定 $(2,4)$ 是 2 的邻接表中最先被删的（不然②不可能停留在2）。

那么满足这些条件的所有方案是不是都能让②去点2呢？答案可以发现是肯定的。

形式化地讲，对于数 $k$ 去点 $u$ 这个事件，假设这条路径是 $v_0=p_k,v_1,v_2,\cdots ,v_m=u$，则充要条件分为三部分：

• $(p_k,v_1)$ 是 $p_k$ 的邻接表中最先删的。
• 在 $v_i$ 的邻接表中，$(v_{i-1},v_i)$ 被删后马上跟着 $(v_i,v_{i+1})$ 被删。
• $(v_{m-1},u)$ 是 $u$ 的邻接表中最后被删的。

接下来我们着手实现贪心算法，我们重新确定一下：

我们考虑贪心，从小到大枚举 $n$ 个数，假设枚举到第 $k$ 个数（此时已经确定 $p_{1\sim k-1}$），找到编号最小的节点 $u$，满足 $k$ 去 $u$ 的充要条件（也就是一堆时间的大小关系）不与 $1\sim k-1$ 的条件的并起冲突（指存在一种构造让这些大小关系都成立）。然后让 $k$ 去 $u$。

我们对于每一个点 $u$ 的邻接表考虑建一个图的模型，将每个边变成点，“$x$ 被删后马上跟着 $y$ 被删” 抽象成 $x\to y$ 连一条边。对于某条边是邻接表中最先删的我们把它叫做 $\text{st}$，最后删的叫 $\text{ed}$，我们尝试挖掘 $p$ 全部确定后这个图模型长什么样。首先必定存在 $\text{st},\text{ed}$，其次由于每条边都要被删，所以这个图模型正好有 ${\text{deg}}_u-1$ 条边。所以这个图一定是 $\text{st}$ 到 $\text{ed}$ 的一条链。 这也是“存在一个构造让邻接表中的所有大小关系都满足”的充要条件。

接下来我们考虑在这个邻接表中只确定了部分大小关系，怎么判断是否存在一种构造满足它们。这等价于我们在图模型上可以加边使得最后图是 $\text{st}$ 到 $\text{ed}$ 的一条链。所以对于这个暂时残缺的图，充要条件是：

• 每个点入度，出度都最多是 1。
• $\text{st}$ 没有入度，$\text{ed}$ 没有出度。
• 若 $\text{st}$ 和 $\text{ed}$ 连通了，则所有边都应该在这个连通块内。

所以若想要加入一条边 $(x,y)$ （还未加）仍然合法，充要条件是

• $x$ 的出度，$y$ 的入度都是 0。$x,y$ 不连通。
• $x$ 不是 $\text{ed}$，$y$ 不是 $\text{st}$。
• 若 $x,y$ 将会使得 $\text{st},\text{ed}$ 连通，则所有点都要在这个连通块内。

若钦定一个点 $x$ 是 $\text{st}$，充要条件是

• 暂时没有 $\text{st}$，且 $x$ 没有入度。
• 若有 $\text{ed}$ 且 $\text{st}$ 与 $\text{ed}$ 连通，则所有点都要在这个连通块内。

若钦定一个点 $x$ 是 $\text{ed}$，跟上述条件差不多。

接下来考虑复杂度，我们使用并查集来判断充要条件，枚举 $k$ 是 $O(n)$，枚举 $u$ 是 $O(n)$，走这一整条路径是 $O(n)$，总共 $O(n^3)$，但考虑到树上的一些单调性，我们从 $u$ 开始向外深搜就能 $O(n)$ 一次判断每个点的合法性，所以总复杂度 $O(n^2)$。

代码

#include <bits/stdc++.h>
using namespace std;

typedef long long ll;
const int MAXN = 100005;

int F[MAXN << 1], siz[MAXN], st[MAXN], ed[MAXN], in[MAXN], out[MAXN];
int get(int x) {
	if (F[x] != x) F[x] = get(F[x]);
	return F[x];
}
void merge(int x, int y) {
	x = get(x), y = get(y); if (siz[x] > siz[y]) swap(x, y);
	siz[y] += siz[x], F[x] = y;
}

int T, N, p[MAXN], ans[MAXN], deg[MAXN];
struct node { int v, next; } E[MAXN << 1]; int head[MAXN], Elen = 1;
void add(int u, int v) { ++Elen, E[Elen].v = v, E[Elen].next = head[u], head[u] = Elen, F[Elen] = Elen, siz[Elen] = 1; }

bool ok[MAXN], used[MAXN]; int fa[MAXN], come[MAXN]; 
void dfs(int u, int ff, int com) {
	come[u] = com, fa[u] = ff;
	if (!ff) {
		for (int i = head[u]; i; i = E[i].next) if (!st[u] && !in[i] && (!ed[u] || get(ed[u]) != get(i) || siz[get(ed[u])] == deg[u]))
			dfs(E[i].v, u, i ^ 1);
	} else {
		if (!ed[u] && !out[com] && (!st[u] || get(st[u]) != get(com) || siz[get(st[u])] == deg[u])) ok[u] = 1;
		for (int i = head[u]; i; i = E[i].next) if (E[i].v != ff) {
			if (get(i) != get(com) && !in[i] && !out[com] && i != st[u] && com != ed[u]) {
				if (get(com) == get(st[u]) && get(i) == get(ed[u]) || get(com) == get(ed[u]) && get(i) == get(st[u])) {
					if (siz[get(st[u])] + siz[get(ed[u])] != deg[u]) continue;
				}
				dfs(E[i].v, u, i ^ 1);
			}
		}
	}
}

int main() {
	scanf("%d", &T);
	while (T--) {
		scanf("%d", &N); int u, v;
		for (int i = 1; i <= N; ++i) scanf("%d", &p[i]);
		for (int i = 1; i < N; ++i) scanf("%d%d", &u, &v), add(u, v), add(v, u), ++deg[u], ++deg[v];
		for (int i = 1; i <= N; ++i) {
			for (int j = 1; j <= N; ++j) ok[j] = 0;
			dfs(p[i], 0, 0);
			for (int j = 1; j <= N; ++j) if (j != p[i] && !used[j] && ok[j]) {
				ans[i] = j, ed[j] = come[j], used[j] = 1;
				int las = come[j] ^ 1;
				u = fa[j];
				while (u != p[i]) {
					merge(come[u], las), ++out[come[u]], ++in[las];
					las = come[u] ^ 1, u = fa[u];
				}
				st[p[i]] = las;
				break;
			}
		}
		for (int i = 1; i <= N; ++i) printf("%d ", ans[i]); putchar('\n');
		for (int i = 1; i <= N; ++i) head[i] = st[i] = ed[i] = deg[i] = used[i] = ans[i] = 0;
		for (int i = 1; i <= Elen; ++i) in[i] = out[i] = 0;
		Elen = 1;
	}
	return 0;
}