[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)\) （不然②就去别的地方了比如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\rightarrow 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;
}