HDU 4126 树形DP + prim

最新推荐文章于 2020-11-19 13:14:47 发布

cyl纤云弄巧

最新推荐文章于 2020-11-19 13:14:47 发布

阅读量376

点赞数

CC 4.0 BY-SA版权

分类专栏： HDOJ dp 文章标签： prim 树形DP

本文链接：https://blog.youkuaiyun.com/Since_natural_ran/article/details/76854324

dp 同时被 2 个专栏收录

98 篇文章

订阅专栏

HDOJ

89 篇文章

订阅专栏

本文介绍了一种结合树形动态规划（DP）与Prim算法解决特定问题的方法。该问题涉及一个连通双向图，通过更新边的权重来求解多次询问下最小生成树的平均值。文章详细阐述了算法思路，包括如何处理边权重变化对最小生成树的影响，并给出了完整的C++代码实现。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

树形DP + prim

题意：

给出一个连通的双向图，每一条边都有权值，现在有q次询问，每次都会更改一条边的cost，问q询问更改之后的平均最小生成树是多少。

注意更改的变的cost比原来大。
所有询问互不干扰

思路：

直接的做法是每次更改之后求出最小生成树，然后相加所有询问情况输出平均值就行，但是q的范围比较大而prim的算法复杂度为 $n^2$ ，所以会超时。考虑一下当更改了一条边会发生什么。

改的边就是原本的最小生成树的边，那么这条边就可以先划去，然后形成两个树，只要找到两棵树的最小的距离就是新的最小生成树.(这里有一个证明：[性质](“http://www.acmerblog.com/hdu-4126-genghis-khan-the-conqueror-7129.html“) )
当改的边不是原来的最小生成树的边，那么对新的生成树来说是无影响的，直接加上mst即可。

树形DP求出非生成树边的最短距离

定义： $dp[i][j]$ 为i节点到j节点的最短距离（非生成树上的边）

当求出dp的时候意味着在替换边的时候直接找出新边的长度。

例如：u到v是原本最小生成树的直接相连的边，现在要求出u到v的除了这条边以外的最短距离。那么只需便利v到除了u以外的其它点的最小距离就行，用dfs进行DP，记录每一个非u点的最小距离。

#include <iostream>
#include <cstdio>
#include <cstring>
#include <vector>

using namespace std;

const int maxn = 3005;
const int inf = 0x3f3f3f3f;

int n,m,q;
long long mst;
int map[maxn][maxn],dp[maxn][maxn];
int dis[maxn],vis[maxn],pre[maxn];
vector<int>G[maxn];

void init()
{
    for(int i = 0;i <= n; i++) {
        for(int j = 0;j <= n; j++) {
            map[i][j] = dp[i][j] = inf;
        }
        G[i].clear();
    }
}

void input()
{
    for(int i = 0;i < m; i++) {
        int a,b,c;
        scanf("%d%d%d",&a,&b,&c);
        map[a][b] = c;
        map[b][a] = c;
    }
}

void prim()
{
    for(int i = 0;i < n; i++) {
        pre[i] = 0;
        vis[i] = 0;
        dis[i] = map[0][i];
    }
    dis[0] = inf;
    vis[0] = 1;
    pre[0] = -1;
    mst = 0;
    for(int i = 0;i < n-1; i++) {
        int k = 0;
        for(int j = 0;j < n; j++) {
            if(!vis[j] && dis[k] > dis[j]) k = j;
        }
        vis[k] = true;
        mst += dis[k];
        if(pre[k] != -1) {
            G[k].push_back(pre[k]);
            G[pre[k]].push_back(k);
        }
        for(int j = 0;j < n; j++) {
            if(!vis[j] && dis[j] > map[k][j]) {
                dis[j] = map[k][j];
                pre[j] = k;
            }
        }
    }
}

int dfs(int pos,int u,int fa)
{
    int ans = inf;
    int len = G[u].size();
    for(int i = 0;i < len; i++) {
        int to = G[u][i];
        if(to == fa) continue;
        int temp = dfs(pos,to,u);
        ans = min(temp,ans);
        dp[u][to] = dp[to][u] = min(dp[u][to],temp);
    }
    if(pos != fa) ans = min(ans,map[pos][u]);
    return ans;
}

void Find()
{
    for(int i = 0;i < n; i++) {
        dfs(i,i,-1);
    }
}

void query()
{
    scanf("%d",&q);
    double ans = 0;
    for(int i = 0;i < q; i++) {
        int a,b,c;
        scanf("%d%d%d",&a,&b,&c);
        if(pre[a] != b && pre[b] != a) ans += mst*1.0;
        else ans += mst*1.0 - map[a][b] + min(dp[a][b],c);
    }
    printf("%.4f\n",ans/q);
}

int main(int argc, char const *argv[])
{
    // freopen("in.txt","r",stdin);
    while(scanf("%d%d",&n,&m) != EOF && n + m) {
        init();
        input();
        prim();
        Find();
        query();
    }
    return 0;
}