树形dp+MST-hdu-4126-Genghis Khan the Conqueror
题目链接：
http://acm.hdu.edu.cn/showproblem.php?pid=4126
题目意思：
给一图，n个点，m条边，每条边有个花费，给出q条可疑的边，每条边有新的花费，每条可疑的边出现的概率相同，求不能经过原来可疑边（可以经过可疑边新的花费构建的边），注意每次只出现一条可疑的边，n个点相互连通的最小花费的期望。
解题思路：
树形dp+MST。
先用kruskal算法找到最小生成树，并求出总花费sum.
再以枚举n个点，依次作为树根dfs,dp[i][j]表示<i,j>为最小生成树上的边，且去掉该边后，包括点i的连通块中的点集A到包括点j的连通块点集B的最小距离。
对于根节点为ro,边为<i,j>的dp[i][j]=min(以j节点为根的子树到ro的最短距离，dp[i][j]).
如下图所示：
以右边点集为子树求出左边点集中每个点作为树根时到all的最小距离。其实对于上面那条边，只用枚举ro个点就行了，但是不好确定每条边的ro集，所以枚举n个点，作为ro,然后dfs,最每条边更新一次，时间复杂度为o(n^2)可以接受。
代码：
#include<iostream>
#include<cmath>
#include<cstdio>
#include<cstdlib>
#include<string>
#include<cstring>
#include<algorithm>
#include<vector>
#include<map>
#include<set>
#include<stack>
#include<list>
#include<queue>
#include<ctime>
#define eps 1e-6
#define INF 0x3f3f3f3f
#define PI acos(-1.0)
#define ll __int64
#define lson l,m,(rt<<1)
#define rson m+1,r,(rt<<1)|1
#pragma comment(linker, "/STACK:1024000000,1024000000")
using namespace std;
#define Maxn 3300
struct Edge
{
int a,b,c;
}edge[Maxn*Maxn]; //保存边的信息
int dis[Maxn][Maxn]; //原始距离
bool hav[Maxn][Maxn]; //是否为最小生成树上的边
int fa[Maxn],dp[Maxn][Maxn];//dp[i][j]表示<i,j>为最小生成树上的边，且去掉该边后，包括点i的连通块中的点集A到包括点j的连通块点集B的最小距离。
int n,m,cnt;
ll sum;
int find(int x) //并查集
{
int tmp=x;
while(x!=fa[x])
x=fa[x];
while(fa[tmp]!=x)
{
int tt=fa[tmp];
fa[tmp]=x;
tmp=tt;
}
return x;
}
bool cmp(struct Edge a,struct Edge b)
{
return a.c<b.c;
}
struct EE //构建最小生成树
{
int v;
struct EE * next;
}ee[Maxn<<1],*head[Maxn<<1];
void add(int a,int b)
{
++cnt;
ee[cnt].v=b;
ee[cnt].next=head[a];
head[a]=&ee[cnt];
}
void kruskal() //克鲁斯卡尔算法求最小生成树
{
sum=0;
cnt=0;
for(int i=1;i<=m;i++)
{
int a=find(edge[i].a),b=find(edge[i].b);
if(a!=b)
{
fa[b]=edge[i].a;
sum+=edge[i].c;
hav[edge[i].a][edge[i].b]=hav[edge[i].b][edge[i].a]=true;
add(edge[i].a,edge[i].b); //建树
add(edge[i].b,edge[i].a);
}
}
}
int dfs(int ro,int fa,int cur,int dep) //表示以cur作为当前子树根中所有子树节点到总根ro的最短距离
{
struct EE * p=head[cur];
int mi=INF;
if(dep!=1) //不为树根的儿子
mi=dis[cur][ro];
while(p)
{
int v=p->v;
if(v!=fa)
{
int tt=dfs(ro,cur,v,dep+1);
mi=min(mi,tt);
dp[cur][v]=dp[v][cur]=min(dp[v][cur],tt);//更新当前边
}
p=p->next;
}
return mi;
}
int main()
{
// printf("%d\n",INF);
while(scanf("%d%d",&n,&m)&&n+m)
{
memset(dis,INF,sizeof(dis));
for(int i=1;i<=m;i++)
{
int a,b,c;
scanf("%d%d%d",&a,&b,&c);
edge[i].a=a,edge[i].b=b,edge[i].c=c;
dis[a][b]=dis[b][a]=c;
}
sort(edge+1,edge+m+1,cmp);
for(int i=0;i<n;i++)
fa[i]=i;
memset(hav,false,sizeof(hav));
memset(head,NULL,sizeof(head));
kruskal();
memset(dp,INF,sizeof(dp));
for(int i=0;i<n;i++) //以每个点最为树根，对每条边更新n次
dfs(i,i,i,0);
ll ans=0;
int q;
scanf("%d",&q);
for(int i=1;i<=q;i++)
{
int a,b,c;
scanf("%d%d%d",&a,&b,&c);
if(hav[a][b]) //是最小生成树上的边
{
int tt=min(dp[a][b],c); //要么用新边，要么用不是最小生成树上的边
ans=ans+sum-dis[a][b]+tt;
}
else //不是最小生成树上的边，直接用最小生成树
ans=ans+sum;
// printf("*%lf\n",ans);
}
printf("%.4f\n",ans*1.0/q);
}
return 0;
}