POJ 2057 树状 DP

SHOHOKUKU

于 2020-05-16 13:19:05 发布

阅读量199

点赞数

分类专栏： DP

本文链接：https://blog.csdn.net/neweryyy/article/details/106157496

版权

DP 专栏收录该内容

159 篇文章 1 订阅

订阅专栏

题意

传送门 POJ 2057

题解

对于某个节点，有屋子在其子树上与不在其子树上两种情况。求步数的最小期望，因为叶子节点数固定，遍历每一种可能的走法，求走到每一个节点（此时假设屋子在该节点）的最小步数和即可。

对于屋子在与不在节点 $i$ 子树上的情况，记为 $suc_{i},fail_{i}$ ；对于其子树的叶子节点数，记为 $son_{i}$ 。考虑到判断屋子不在屋子上的情况，需要搜索每一条分支

$fail_{p}=\sum_{ch在p的子树上}(fail_{ch}+2)$

对于叶子节点的统计

$son_{p}=\sum_{ch在p的子树上}son_{ch}$

在某种顺序下，求屋子在节点 $p$ 子树的步数和，要考虑到走到当前处理子节点时，之前搜索的子节点要确认无屋子，且要重复当前处理子节点的叶子节点数次

$suc_{p}=\sum_{ch_{i}在p的子树上}suc_{ch_{i}}+son_{ch_{i}}+son_{i}\times \sum_{ch_{i},ch_{j}在p的子树上,且j在i之前搜索到}(fail_{ch_{j}}+2)$

对于叶子节点

$son_{i}=1,fail_{i}=suc_{i}=0$

对于有 $n$ 个子节点的节点，搜索全部路线需要 $O (n!)$ ，考虑优化；对于连续选择的子节点 $i, j$ ，其交换搜索顺序前后对其余子节点的结果无影响，先搜索 $i$ 时需要满足步数和最小

$suc_{i}+son_{i}+suc_{j}+son_{j}+(fail_{i}+2)\times son_{j}<suc_{i}+son_{i}+suc_{j}+son_{j}+(fail_{j}+2)\times son_{i}$

化简

$(fail_{i}+2)\times son_{j}<(fail_{j}+2)\times son_{i}$

对于每个节点排序即可求解最优顺序。

#include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <map>
#include <queue>
#include <vector>
#define min(a, b) (((a) < (b)) ? (a) : (b))
#define max(a, b) (((a) > (b)) ? (a) : (b))
#define abs(x) ((x) < 0 ? -(x) : (x))
#define INF 0x3f3f3f3f
#define delta 0.85
using namespace std;

#define maxn 1005
int N;
int worm[maxn];
int suc[maxn], fail[maxn], son[maxn];
vector<int> G[maxn];

bool cmp(int a, int b)
{
	return (fail[a] + 2) * son[b] < (fail[b] + 2) * son[a];
}

void dfs(int p)
{
	int n = G[p].size();
	if (n == 0)
	{
		son[p] = 1, suc[p] = fail[p] = 0;
		return;
	}
	vector<int> &ch = G[p];
	for (int i = 0; i < n; i++)
	{
		dfs(ch[i]);
	}
	sort(ch.begin(), ch.end(), cmp);
	int fsum = 0;
	for (int i = 0; i < n; i++)
	{
		int u = ch[i];
		if (worm[p])
		{
			fail[p] = 0;
		}
		else
		{
			fail[p] += fail[u] + 2;
		}
		son[p] += son[u];
		suc[p] += suc[u] + son[u] * (1 + fsum);
		fsum += fail[u] + 2;
	}
}

void solve()
{
	memset(suc, 0, sizeof(suc));
	memset(fail, 0, sizeof(fail));
	memset(son, 0, sizeof(son));
	dfs(0);
	printf("%.4lf\n", (double)suc[0] / son[0]);
}

int main()
{
	while (~scanf("%d", &N) && N)
	{
		for (int i = 0; i < N; i++)
		{
			G[i].clear();
		}
		for (int i = 0; i < N; i++)
		{
			int u;
			char c;
			scanf("%d %c", &u, &c);
			worm[i] = (c == 'Y' ? 1 : 0);
			if (i > 0)
			{
				G[u - 1].push_back(i);
			}
		}
		solve();
	}
	return 0;
}