【CodeForces - 697D】Puzzles（概率、期望、树形dp）

Barney lives in country USC (United States of Charzeh). USC has n cities numbered from 1 through n and n - 1 roads between them. Cities and roads of USC form a rooted tree (Barney's not sure why it is rooted). Root of the tree is the city number 1. Thus if one will start his journey from city 1, he can visit any city he wants by following roads.

Some girl has stolen Barney's heart, and Barney wants to find her. He starts looking for in the root of the tree and (since he is Barney Stinson not a random guy), he uses a random DFS to search in the cities. A pseudo code of this algorithm is as follows:

let starting_time be an array of length n
current_time = 0
dfs(v):
	current_time = current_time + 1
	starting_time[v] = current_time
	shuffle children[v] randomly (each permutation with equal possibility)
	// children[v] is vector of children cities of city v
	for u in children[v]:
		dfs(u)

As told before, Barney will start his journey in the root of the tree (equivalent to call dfs(1)).

Now Barney needs to pack a backpack and so he wants to know more about his upcoming journey: for every city i, Barney wants to know the expected value of starting_time[i]. He's a friend of Jon Snow and knows nothing, that's why he asked for your help.

Input

The first line of input contains a single integer n (1 ≤ n ≤ 105) — the number of cities in USC.

The second line contains n - 1 integers p2, p3, ..., pn (1 ≤ pi < i), where pi is the number of the parent city of city number i in the tree, meaning there is a road between cities numbered pi and i in USC.

Output

In the first and only line of output print n numbers, where i-th number is the expected value of starting_time[i].

Your answer for each city will be considered correct if its absolute or relative error does not exceed 10 - 6.

Examples

input

Copy

7
1 2 1 1 4 4

output

Copy

1.0 4.0 5.0 3.5 4.5 5.0 5.0 

input

Copy

12
1 1 2 2 4 4 3 3 1 10 8

output

Copy

1.0 5.0 5.5 6.5 7.5 8.0 8.0 7.0 7.5 6.5 7.5 8.0 

题意：

给一段伪代码，代表到一个节点时随机遍历其孩子结点，问每个结点的遍历时间的期望。

思路：（参考博客）

每个结点的遍历时间与父节点遍历时间和父节点的其他子树有关。假设父节点为u，其子节点个数为k。则遍历方式总共与k!种，考虑其中两颗子树v,w。假设要求v的，则这两个子树的关系就是w在v前面，和w在v后面。而且这两种的出现的概率四相同的，并且后者是不会对v的遍历时间产生影响，因此只考虑前者。设all[w]代表w结点及其子节点的个数，则w这颗子树对v的贡献就是(all[w]+0)/2，一半的概率会带来all[w]的贡献，另一半无贡献。因此在求一颗子树的遍历时间期望时，就是父节点的遍历时间的期望加上其他k-1个结点的贡献再+1。这里的加1是因为v结点的遍历时间是上一个遍历结点的时间+1。设dp数组为某个点遍历时间的期望，son代表某个点的孩子结点的数量。转移方程为：dp[v]=dp[u]+(son[u]-son[v]-1)/2+1

对于这种问题，可以简化考虑，首先是只考虑两层之间的关系，其余的都转换为两层之间关系。然后就是考虑子结点与其他结点的关系时，考虑是不是每一个其他子树对当前的子树的影响是一样的，如果是这样，那就考虑两个子树之间关系的转移，然后多个子树求个加和就可以。

ac代码：

#include<iostream>
#include<cstdio>
#include<algorithm>
#include<cmath>
#include<cstring>
#include<queue>
#include<stack>
#include<map>
#include<set>
#include<string>
#include<vector>
#include<unordered_map>
#define mod (1000000007)
using namespace std;
typedef long long ll;
const int maxn=2e5+10;
struct node{
	int v,nxt;
}side[maxn<<1];
int head[maxn],cnt=0,son[maxn];
double dp[maxn]={0};
void add(int x,int y){
	side[cnt].v=y;
	side[cnt].nxt=head[x];
	head[x]=cnt++;
}
void dfs1(int u,int fa){
	for(int i=head[u];i!=-1;i=side[i].nxt){
		int ty=side[i].v;
		if(ty==fa)continue;
		dfs1(ty,u);
		son[u]+=son[ty]+1;
	}
}
void dfs2(int u,int fa){
	dp[u]=dp[fa]+(son[fa]-son[u]-1)/2.0+1;
	for(int i=head[u];i!=-1;i=side[i].nxt){
		int ty=side[i].v;
		if(ty==fa)continue;
		dfs2(ty,u);
	}
}
int main(){
	int n,fa;
	scanf("%d",&n);
	for(int i=0;i<=n;i++) head[i]=-1;
	for(int i=2;i<=n;i++){
		scanf("%d",&fa);
		add(fa,i);
		add(i,fa);
	}
	dfs1(1,0); 
	dp[1]=1;son[0]=son[1]+1,dp[0]=0;
	dfs2(1,0);
	for(int i=1;i<=n;i++) printf("%.6f%c",dp[i],i==n?'\n':' ');
	return 0;
}