【POJ2057】The Lost House【TreeDP】

【题目链接】

比较经典的一道TreeDP。

因为概率是相等的，所以我们只需要计算最小步数即可，最后答案再除以叶子节点个数。

设leaf[u]表示以u为根的子树中叶子节点的个数。

设fail[u]表示以u为根的子树中，从u出发，找房子失败后，回到u点，按最优策略走的步数。

设succ[u]表示以u为根的子树中，从u出发，并成功找到房子，按最优策略走的步数。

最优策略即我们要找一个最佳的遍历叶节点的顺序。

假设我们已知了最优遍历顺序，那么考虑递推转移（不好说，直接看伪代码）：

for v 按照最优遍历顺序
	succ[u] += (fail[u] + 1) * leaf[v] + succ[v]
	fail[u] += fail[v] + 2
	leaf[u] += leaf[v]

在递推中，fail[u]代表在已经遍历过的子树中走过的路径长度。

主要看succ[u]那句，给fail[u]再加1表示从u走到v的路程为1。再乘上leaf[v]是因为v子树中每个叶子节点都要贡献(fail[u] + 1)个长度。最后加上succ[v]就没啥好说的了。

每个子树的答案是succ[u] / leaf[u]。

现在考虑如何确定最优遍历顺序。

首先要确定的是，两棵相邻子树的遍历顺序是不会影响到前面和后面的子树的贡献的。

然后就可以考虑贪心排序了。

令先走x再走y 比 先走y再走x 更优，有

(fail[u] + 1) * leaf[x] + succ[x] + (fail[u] + fail[x] + 3) * leaf[y] + succ[y] < (fail[u] + 1) * leaf[y] + succ[y] + (fail[u] + fail[y] + 3) * leaf[x] + succ[x]

化简之后得

(fail[x] + 2) * leaf[y] < (fail[y] + 2) * leaf[x]

那么按这个排序，就可以得到最优遍历顺序了。

/* Pigonometry */
#include <cstdio>
#include <algorithm>

using namespace std;

const int maxn = 1005;

int n, head[maxn], cnt, fail[maxn], leaf[maxn], succ[maxn], du[maxn];
bool worm[maxn];

struct _edge {
	int v, next;
} g[maxn << 1];

inline int iread() {
	int f = 1, x = 0; char ch = getchar();
	for(; ch < '0' || ch > '9'; ch = getchar()) f = ch == '-' ? -1 : 1;
	for(; ch >= '0' && ch <= '9'; ch = getchar()) x = x * 10 + ch - '0';
	return f * x;
}

inline void add(int u, int v) {
	g[cnt] = (_edge){v, head[u]};
	head[u] = cnt++;
}

inline bool cmp(int x, int y) {
	return (fail[x] + 2) * leaf[y] < (fail[y] + 2) * leaf[x];
}

inline void dfs(int x) {
	if(du[x] == 1 && x != 1) {
		leaf[x] = 1;
		return;
	}

	int tmp[maxn], tot = 0;
	for(int i = head[x]; ~i; i = g[i].next) {
		dfs(g[i].v);
		tmp[++tot] = g[i].v;
	}
	sort(tmp + 1, tmp + 1 + tot, cmp);

	for(int i = 1; i <= tot; i++) {
		int v = tmp[i];
		succ[x] += (fail[x] + 1) * leaf[v] + succ[v];
		fail[x] += fail[v] + 2;
		leaf[x] += leaf[v];
	}
	if(worm[x]) fail[x] = 0;
}

int main() {
	while(1) {
		n = iread();
		if(!n) break;

		for(int i = 0; i <= n; i++) head[i] = -1, du[i] = fail[i] = leaf[i] = succ[i] = worm[i] = 0; cnt = 0;

		for(int i = 1; i <= n; i++) {
			int x = iread();
			if(~x) {
				add(x, i); du[x]++; du[i]++;
			}
			char ch = getchar(); for(; ch != 'Y' && ch != 'N'; ch = getchar());
			worm[i] = ch == 'Y';
		}

		dfs(1);
		printf("%.4f\n", succ[1] / (double) leaf[1]);
	}
	return 0;
}

判叶子节点的时候忘了根也有可能度为1，WA了无数发。