蒟蒻用了一个十分麻烦的方法…
思路:设f[i]代表从1号节点走到i号节点的概率,deep代表i号节点的深度(设1好节点深度为0).
那么,由于这是一颗树,所以 只要统计每个叶节点到根节点的距离(也就是叶节点的深度)与从根节点走到i号节点的概率 求和就可以了
从u节点走到下一个节点的概率是 1/son[u] (son[i]代表i号节点的子节点个数)
设fa[i]为i的父节点
则f[i] = f[fa[i]] * (1.0/son[i])
最后统计叶节点 deep[left] * f[i]就好了
至于我的做法:
首先用vector存图,求出树的深度,并记录树节点的遍历顺序,重新进行建(单向向下的)树,然后进行dfs到tree[u].size()为0(没有儿子,也就是叶节点)的点,进行求和
#include <iostream>
#include <string.h>
#include <stdio.h>
#include <algorithm>
#include <vector>
#define maxn 100010
using namespace std ;
int n ;
vector<int>tree[maxn] ;
int read(){
int x = 0 , f = 1 ; char s = getchar() ;
while(s > '9' || s < '0') {if(s == '-') f = -1 ; s = getchar() ;}
while(s <='9' && s >='0') {x = x * 10 + (s-'0'); s = getchar() ;}
return x*f ;
}double f[maxn] ;
int deep[maxn] , vis[maxn] , F[maxn] ;
void dfs(int u ,int fa,int dep) {
deep[u] = dep + 1 ;
vis[u] = 1 ;
F[u] = fa ;
for(int i = 0 ; i < tree[u].size() ; i ++ ) {
int v = tree[u][i] ;
if(vis[v] || v == fa) continue ;
dfs(v,u,dep+1) ;
}
}
double ans = 0 ;
void Dfs(int u) {
vis[u] = 1 ;
if(!tree[u].size()) {
ans += f[F[u]]*deep[u] ;
}else
f[u] = f[F[u]]*(1.0/tree[u].size()) ;
for(int i = 0 ; i < tree[u].size() ; i ++) {
int v = tree[u][i] ;
Dfs(v) ;
}
}
int main () {
n = read() ;
for(int i = 1 ; i < n ; i ++) {
int x = read() , y = read() ;
tree[x].push_back(y) ;
tree[y].push_back(x) ;
}dfs(1,0,-1) ;
f[0] = 1 ;
memset(vis,0,sizeof(vis)) ;
memset(tree,0,sizeof(tree)) ;
for(int i = 1 ; i <= n ; i ++) {
tree[F[i]].push_back(i) ;
}
Dfs(1) ;
printf("%.15lf",ans) ;
return 0 ;
}