@atcoder - AGC034E@ Complete Compress

目录

• @description@
• @solution@
• @accepted code@
• @details@

---

@description@

给定一个 N 个点的树，编号为 1, 2, ..., N。第 i 条边连接 ai 与 bi。

再给定一个长度为 N 的 01 串，第 i 个字符表示 i 号点上是否有一个棋子。

保证至少有一个点有棋子。

你可以执行如下操作若干次：

选择两个距离 >= 2 的棋子，将这两个棋子往靠近对方的方向分别移动 1 条边。

是否可以通过若干次操作将所有棋子集中于一个点。如果可以，求出最小操作次数。

Constraints

2≤N≤2000

|S|=N，只包含 0, 1 且至少有一个 1。

1≤ai,bi≤N(ai≠bi) 且形成一棵树。

Input

输入形式如下：

N

S

a1 b1

a2 b2

:

aN−1 bN−1

Output

如果不可能集中所有棋子，输出 -1；

否则输出最小操作次数。

Sample Input 1

7

0010101

1 2

2 3

1 4

4 5

1 6

6 7

Sample Output 1

3

@solution@

N 这么小，显然可以枚举最后集中的点，然后进行判断。

考虑规定了集中的点后，怎么快速判断是否合法。我们尝试去找操作下的不变量。

显然操作要分成两类：祖先关系与非祖先关系。

祖先关系的操作会将一个点拉低，一个点抬高；另一种操作会同时将两个点抬高。

那么深度和的奇偶性是不会变的。

同时发现两种操作下，深度和要么不变，要么减少 2。而当深度和 = 0 时所有点集中于一点。

那么我们可以忽略祖先操作，只剩下非祖先操作，那么深度和每次严格减少 2。只要可行，最小操作次数 = 深度和 / 2。

当然需要稍微证明一下这个的合法性：祖先关系的操作总可以与下一个操作交换。于是可以将所有祖先操作挪到最后。然后就没用了。

怎么判断是否可行呢？考虑根，如果只对根的不同子树进行操作都可以合法的话自然合法。

求出根的每棵子树的深度和。相当于每次操作选出两棵子树，它们的深度和分别减一。

若干正整数 a1, a2, ..., ak，每次操作同时选两个数减一，问是否可以全部减成 0。这其实是一个很经典的问题。

解决方法是比较 sum - max{ai} 与 max{ai}。如果 sum - max{ai} < max{ai}，显然最后会剩下 max{ai} - (sum - max{ai})；否则，一定可以消到只剩 0 或 1（取决于 sum{ai} 的奇偶性）。

假如只操作根就是这样。

假如还可以操作其他子树内的点，我们显然应该递归去 max{ai} 的那一棵子树，看最后能够得到最小深度和。

再将最终得到的最小深度和拿去上面的判定条件判断一下，就可以知道当前能够剩下的最小深度和。

@accepted code@

#include<cstdio>
#include<algorithm>
using namespace std;
const int MAXN = 2000;
const int INF = (1<<30);
struct edge{
	int to; edge *nxt;
}edges[2*MAXN + 5], *adj[MAXN + 5], *ecnt=&edges[0];
void addedge(int u, int v) {
	edge *p = (++ecnt);
	p->to = v, p->nxt = adj[u], adj[u] = p;
	p = (++ecnt);
	p->to = u, p->nxt = adj[v], adj[v] = p;
}
int a[MAXN + 5], N;
int f[MAXN + 5], s[MAXN + 5];
void dfs(int x, int fa) {
	s[x] = a[x], f[x] = 0;
	for(edge *p=adj[x];p;p=p->nxt) {
		if( p->to == fa ) continue;
		dfs(p->to, x), s[x] += s[p->to];
		f[x] += f[p->to] + s[p->to];
	}
}
int get(int x, int fa) {
	int mx = 0;
	for(edge *p=adj[x];p;p=p->nxt) {
		if( p->to == fa ) continue;
		if( mx == 0 || f[p->to] > f[mx] ) mx = p->to;
	}
	if( mx == 0 ) return 0;
	int k = get(mx, x) + s[mx];
	if( f[x] - f[mx] - s[mx] >= k ) return f[x] & 1;
	else return k - (f[x] - f[mx] - s[mx]);
}
char S[MAXN + 5];
int main() {
	scanf("%d%s", &N, S + 1);
	for(int i=1;i<=N;i++) a[i] = S[i] - '0';
	for(int i=1;i<N;i++) {
		int u, v; scanf("%d%d", &u, &v);
		addedge(u, v);
	}
	int ans = INF;
	for(int j=1;j<=N;j++) {
		dfs(j, 0);
		if( get(j, 0) == 0 )
			ans = min(ans, f[j]/2);
	}
	if( ans == INF ) printf("-1\n");
	else printf("%d\n", ans);
}

@details@

惊了，这一场 AGC 的过题人数 E > F > D。

其实 E 还是比较容易往正解想。而且就算不会那个经典的模型，你也可以使用树形 dp 来搞定。