HDU 4126 Genghis Khan the Conqueror MST + 树形DP 2011年福州现场赛F题

题目大意：

就是现在给出一个图, N个点, M条边, N <= 3000, M <= N*N, 但是没有重边, 每条边都有一个权值, 图中没有自环

现在给出Q次询问, 每次询问表示如果更改边(u, v)的权值为c, c一定比之前那个权值大, 那么改变这条边之后得到的图的最小生成树的权值是多少

输出Q次查询对应MST的权值的和除以Q, 保留小数点后4位

大致思路：

首先我们可以用Prim预处理出原图的最小生成树, 那么记录这颗树上使用的边

如果更改发生在不是最小生成树上的边上, 那么答案不变, 就是这个最小生成树的权值

如果改变发生在这棵生成树上的边中, 一定会将这棵最小生成树分成两棵树, 可以证明, 新图的最小生成树一定可以是包含这两棵树上所有的边的树, 可以用反证法证明, 如果(u, v)是生成的两棵树上的边且不能成为新的最小生成树上的边, 那么这条边也不能成为原最小生成树上的边

那么问题变成对于原来的最小生成树被切成两棵树之后, 如何选择权值最小的一条边将两棵树连通

这个问题是用DP来解决的

首先在找到最小生成树之后

用dp[i][j]表示最小生成树上点 i 到以点j为根节点的子树的最短边的权值(这里i视作整棵树的根), 于是算出dp[i][j]需要枚举以i为根结点, 遍历一遍树, 时间复杂度是O(n^2), 注意dp[i][j]在计算时, 如果j是i个儿子, 那么w[i][j]不能为dp[i][j]做出贡献(为了接下来best[i][j]方便计算, 视作删掉了边(i, j))

然后用best[i][j]表示如果删去最小生成树上的边(i, j), 最小的替代边权值是多少 (只有MST上有(i, j)边的时候best[ i ][ j ]有意义)

那么求出best[i][j]只需要判断所有以j为根时, i及其子树上的点u, dp[u][j]的最小值即可

那么当改变的边(u, v)是MST上的边时, 结果是原MST的权值 - w[u][v] + min(新(u, v)权值,best[u][v])

代码如下：

Result  :  Accepted     Memory  :  116780 KB     Time  :  1404 ms

/*
 * Author: Gatevin
 * Created Time:  2015/7/24 14:05:16
 * File Name: D.cpp
 */
#include<iostream>
#include<sstream>
#include<fstream>
#include<vector>
#include<list>
#include<deque>
#include<queue>
#include<stack>
#include<map>
#include<set>
#include<bitset>
#include<algorithm>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<cctype>
#include<cmath>
#include<ctime>
#include<iomanip>
using namespace std;
const double eps(1e-8);
typedef long long lint;

#define maxn 3010

vector <int> G[maxn];//保存最小生成树
int w[maxn][maxn];
int n, m;
#define inf 1e9
int dis[maxn];//dis[u]表示prim过程中点连通块通过1条边到u最短距离
bool vis[maxn];
int pre[maxn];
bool mst[maxn][maxn];
int dp[maxn][maxn];
int best[maxn][maxn];
lint sum;

void Prim()
{
    fill(dis, dis + n + 1, inf);
    memset(vis, 0, sizeof(vis));
    memset(mst, 0, sizeof(mst));
    dis[1] = 0; vis[1] = 1;//从点1开始
    for(int i = 2; i <= n; i++)
        if(w[1][i] < dis[i])
            dis[i] = w[1][i], pre[i] = 1;
    int now = -1;
    for(int times = 1; times < n; times++)
    {
        for(int j = 1; j <= n; j++)
           if(!vis[j] && (now == -1 || dis[j] < dis[now]))
               now = j;//找出接下来要加入的点
        if(now == -1 || dis[now] == inf) break;//mst不存在
        mst[now][pre[now]] = mst[pre[now]][now] = 1;//表示边(j, pre[j])是最小生成树中的边
        sum += dis[now];
        vis[now] = 1;
        G[now].push_back(pre[now]);
        G[pre[now]].push_back(now);
        for(int j = 1; j <= n; j++)
        {
            if(vis[j]) continue;
            if(dis[j] > w[now][j])
                dis[j] = w[now][j], pre[j] = now;
        }
        now = -1;
    }
    return;
}

void dfs1(int now, int fa, int start)
{
    for(int i = 0, sz = G[now].size(); i < sz; i++)
    {
        int u = G[now][i];
        if(u == fa) continue;
        dfs1(u, now, start);
        if(start != now)
            dp[start][now] = min(dp[start][now], dp[start][u]);
    }
    if(fa != -1 && fa != start && now != start) dp[start][now] = min(dp[start][now], w[start][now]);
    return;
}

void dfs2(int now, int fa, int start)
{
    for(int i = 0, sz = G[now].size(); i < sz; i++)
    {
        int u = G[now][i];
        if(u == fa) continue;
        dfs2(u, now, start);
        if(now != start)
            best[now][start] = min(best[u][start], best[now][start]);
    }
    if(now != start)
        best[now][start] = min(best[now][start], dp[now][start]);
    return;
}

void solve()
{
    for(int i = 1; i <= n; i++)
        for(int j = 1; j <= n; j++)
            best[i][j] = dp[i][j] = inf;
    for(int i = 1; i <= n; i++)
        dfs1(i, -1, i);//每一次算出从i点到以j为根的子树的的最短距离(距离只用一条边)为dp[i][j]
    for(int i = 1; i <= n; i++)
        dfs2(i, -1, i);
    return;
}



int main()
{
    while(scanf("%d %d", &n, &m), n || m)
    {
        for(int i = 1; i <= n; i++) G[i].clear();
        for(int i = 1; i <= n; i++)
            for(int j = 1; j <= n; j++)
                w[i][j] = inf;
        for(int i = 0; i < m; i++)
        {
            int u, v, ww;
            scanf("%d %d %d", &u, &v, &ww);
            u++, v++;
            w[u][v] = w[v][u] = ww;
        }
        sum = 0;
        Prim();
        solve();
        int Q;
        scanf("%d", &Q);
        double ans = 0;
        for(int i = 0; i < Q; i++)
        {
            int u, v, ww;
            scanf("%d %d %d", &u, &v, &ww);
            u++, v++;
            if(!mst[u][v]) ans += sum;
            else ans += sum - w[u][v] + min(ww, best[u][v]);//取min是为了防止除了(u, v)之外没有可替代的边
        }
        ans /= Q;
        printf("%.4f\n", ans);
    }
    return 0;
}