hdu4126Genghis Khan the ConquerorGenghis Khan the Conqueror(MST+树形DP)
题目大意：给n个点，m条边，每条边权值c，现在要使这n个点连通。现在已知某条边要发生突变，再给q个三元组，每个三元组(a,b,c)，(a,b)表示图中可能发生突变的边，该边一定是图中的边。c表示该边新的权值，c只可能比原来的权值大。给的q条边发生突变的概率是一样的。求突变后连通n个点最小代价期望值。
题目分析：如果没有那条突变的边，就是求一个mst。但是因为有一条边要突变，每条边突变的概率相同，都为1/q。所以要枚举所有的q条边，求出该边突变后最小生成树代价。q条边分2类：一类是生成树中的边，第二类不是生成树中的边。
第二类边很好处理，既然本身不是生成树中的边。那么这条边突变后权值变大，现在要使权值最小，这条边不选就是了，所以总代价依然是原图的mst。
第一类边发生突变的话，那么去掉这条边后原来的mst就被分成了2个子树，所以我们要找到解决办法就是寻找这2个子树之间的次短边（最小边是去掉的那条生成树中的边）。比较一下，如果这条次短边的权值小于这条突变的生成树上的边，那么就要换掉这条边，否则保留。
现在的关键是求去掉某条边生成树边后，2个子树的最小距离。很容易想到一个O(n^3)的算法：枚举每条生成树边(u,v),分别从u和v开始沿着生成树边遍历，求出两两点间最小值。可是复杂度未免太高。借助dp的思想，可以将这个过程复杂度降一个n。
考虑次过程的这样一个性质：求某个点i到以点j为根的树的最短距离=min（i到j所有子树的最短距离，i到j的最短距离），那么可以枚举起点i，从i点开始沿着mst的边dfs，每经过一条边，那么这条边可以将n个点分成2部分，一部分含i，另一部分不含i（废话），利用dfs的性质，对于从i出发沿着生成树的边遍历到的每个点，当要离开这个点的时候，保证其所有的子树都已经遍历完毕，那么i到j的子树的最短距离就确定了，那么以到达j的边为割边，i到j这颗子树的最短距离就有了。每一次从i点的dfs表示的是枚举割边后包含i的子树和不包含i的子树之间的最小距离。枚举每个点，就能得到对于所有生成树的边，dp[u][v]表示以(u,v)为割边的两颗子树的最短距离。
好NB的DP！
汉语组织的可能不是很好，具体画图吧，好容易懂的。
详情请见代码：
#include <iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
const int N = 3005;
const int M = 1000005;
const int inf = 0x3f3f3f3f;
int dp[N][N],dis[N][N],cost[N][N],lowcost[N],pre[N];
bool used[N][N],flag[N];
int head[N],num;
double ans;
int n,m,q,mst;
struct node
{
int to,next;
}e_mst[M];
void build(int s,int e)
{
e_mst[num].to = e;
e_mst[num].next = head[s];
head[s] = num ++;
}
void prim()
{
int i,j;
mst = 0;
memset(flag,false,sizeof(flag));
for(i = 0;i < n;i ++)
{
lowcost[i] = dis[0][i];
pre[i] = 0;
}
flag[0] = true;
for(i = 1;i < n;i ++)
{
int minn = inf;
int v;
for(j = 0;j < n;j ++)
{
if(lowcost[j] < minn && flag[j] == false)
{
minn = lowcost[j];
v = j;
}
}
mst += minn;
used[pre[v]][v] = used[v][pre[v]] = true;
build(pre[v],v);
build(v,pre[v]);
flag[v] = true;
for(j = 0;j < n;j ++)
{
if(flag[j] == false && lowcost[j] > dis[v][j])
{
lowcost[j] = dis[v][j];
pre[j] = v;
}
}
}
}
int dfs(int cur,int u,int fa)//用cur更新cur点所在的子树和另外子树的最短距离
{
int ret = inf;
for(int i = head[u];~i;i = e_mst[i].next)//沿着生成树的边遍历
{
if(e_mst[i].to == fa)
continue;
int tmp = dfs(cur,e_mst[i].to,u);//用cur更新的以当前边(u,e_mst[i].to)为割边的两个子树最短距离
ret = min(tmp,ret);//以(fa,u)为割边的2个子树的最短距离
dp[u][e_mst[i].to] = dp[e_mst[i].to][u] = min(dp[u][e_mst[i].to],tmp);
}
if(fa != cur)//生成树边不更新
ret = min(ret,dis[cur][u]);
return ret;
}
void solve()
{
int i,j;
int a,b,c;
int sum = 0;
memset(head,-1,sizeof(head));
num = 0;
prim();
for(i = 0;i < n;i ++)
dfs(i,i,-1);
scanf("%d",&q);
for(i = 0;i < q;i ++)
{
scanf("%d%d%d",&a,&b,&c);
if(used[a][b])
{
if(c < dp[a][b])
sum += (mst - dis[a][b] + c);
else
sum += (mst - dis[a][b] + dp[a][b]);
}
else
sum += mst;
}
ans = (double)sum/(double)q;
printf("%.4lf\n",ans);
}
int main()
{
int i,j,a,b,c;
while(scanf("%d%d",&n,&m),(m + n))
{
for(i = 0;i < n;i ++)
for(j = 0;j < n;j ++)
{
dp[i][j] = inf;
used[i][j] = false;
if(i == j)
dis[i][j] = 0;
else
dis[i][j] = inf;
}
for(i = 0;i < m;i ++)
{
scanf("%d%d%d",&a,&b,&c);
dis[a][b] = dis[b][a] = c;
}
solve();
}
return 0;
}
//921MS 80028K