HDU 4126 Genghis Khan the Conqueror prim + 树形DP 好题

最新推荐文章于 2024-05-22 17:32:19 发布
转载 最新推荐文章于 2024-05-22 17:32:19 发布 · 403 阅读 · 0

探讨了在一个无向图中生成最小生成树后，针对特定边权的变化如何高效更新最小生成树的问题。通过预处理及树形动态规划的方法，实现了对大量查询的快速响应。

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

转载：http://www.cnblogs.com/ACMan/archive/2012/10/07/2713690.html

题意：

一个N个点的无向图，先生成一棵最小生成树，然后给你Q次询问，每次询问都是x,y,z的形式， 表示的意思是在原图中将x,y之间的边增大(一定是变大的)到z时，此时最小生成数的值是多少。最后求Q次询问最小生成树的平均值。 N<=3000 , Q<=10000

思路：

先求出该图的最小生成树，用prim()， O(n^2)。

对于每次询问， 都是将a，b之间的边增加到c， 会出现 两种情况：

1. 如果边权增加的那条边原先就不在最小生成树中，那么这时候的最小生成树的值不变

2. 如果在原最小生成树中，那么这时候将增加的边从原最小生成树中去掉，这时候生成树就被分成了两个各自联通的部分，可以证明的是，这时候的最小生成树一定是将这两部分联通起来的最小的那条边。

问题转化：

首先我们先求出最小生成树，然后将在最小生成树中边去掉，对于每条最小生成树中的边，我们要求出它的替代边， 并且要求该替代边最小。

对于询问Q（10000） 分析一下Q里面的复杂度必须是O(n) 或 O(1)。

我们需要在外面预处理求出一些跟能推出答案但推出过程的复杂度是以上2个的其中1个。

 

 

 方法一：

假设两个各自连通的部分分别为树A，树B

1. 用dp[i][j]表示树A中的点i 到 树B（j点所在的树）的最近距离，这个过程可以在一边dfs就可以出来，对于每个 i 的dfs 复杂度是O(n) ，外加一个n的循环求出每个点，这里的总复杂度为 O(n^2)。

2. 通过求出来的dp[i][j] 再用一个dfs 求出  树B 到 树A的最近距离，（方法：枚举树A中的所有点 到 树B的最近距离，取其中的最小值。）显然， 这个求出来的值是我们要的最小替代边，把它保存到一个best[i][j]数组里面，（best[i][j]表示去掉边<i，j>后它的最小替代边的值）这里的总复杂度为 O(n^2)。

代码：

#include<stdio.h>
#include<string.h>
#include<algorithm>
#include<vector>
using namespace std;

const int maxn = 3003;
const int maxm = maxn * maxn;
const int inf = 1000000000;

int n, m;
__int64 mst;
int map[maxn][maxn];
int dp[maxn][maxn], best[maxn][maxn];
int dis[maxn], pre[maxn];
bool vis[maxn];
vector<int> edge[maxn];

int minz(int a, int b)
{
    return a < b ? a : b;
}
void init()
{
    int i, j;
    for(i = 0; i < n; i++)
    {
        for(j = 0; j < n; j++)
            map[i][j] = dp[i][j] = inf;
        edge[i].clear();
        vis[i] = 0;
        pre[i] = -1;
        dis[i] = inf;
    }
}
void input()
{
    int x, y, z;
    while(m--)
    {
        scanf("%d%d%d", &x, &y, &z);
        map[x][y] = map[y][x] = z;
    }
}

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

        vis[k] = 1;
        mst += dis[k];
       //建最小生成树
        if(pre[k] != -1)
            edge[k].push_back(pre[k]),
            edge[pre[k]].push_back(k);

        for(j = 1; j < n; j++)
            if(!vis[j] && dis[j] > map[k][j] )
                dis[j] = map[k][j], pre[j] = k;
    }
}

int dfs1(int u, int fa, int rt) // 求 点rt 到 以u为根的数及其子树的最小距离
{
    int i;
    for(i = 0; i < edge[u].size(); i++)
    {
        int v = edge[u][i];
        if(v == fa) continue;
        dp[rt][u] = minz(dp[rt][u], dfs1(v, u, rt));
    }
    if(fa != rt) dp[rt][u] = minz(dp[rt][u], map[rt][u]);
    return dp[rt][u];
}

int dfs2(int u, int fa, int rt) // 求 以rt为根的数及其子树 到 以u为根的数及其子树的最小距离
{
    int i;
    int ans = dp[u][rt];
    for(i = 0; i < edge[u].size(); i++)
    {
        int v = edge[u][i];
        if(v == fa) continue;
        ans = minz(ans, dfs2(v, u, rt));
    }
    return ans;
}

void solve()
{
    int i,j;
    for(i = 0; i < n; i++)
        dfs1(i, -1, i);
    for(i = 0; i < n; i++)
        for(j = 0; j < edge[i].size(); j++)
        {
            int v = edge[i][j];
            best[i][v] = best[v][i] = dfs2(v, i, i);
        }
}
void query()
{
    int x, y, z;
    double sum = 0;
    scanf("%d", &m);
    for(int ii = 1; ii <= m; ii++)
    {
        scanf("%d%d%d", &x, &y, &z);
        if(pre[x] != y && pre[y] != x)
            sum += mst * 1.0;
        else
            sum += mst * 1.0 - map[x][y] + minz(best[x][y], z);
    }
    printf("%.4f\n", sum/m);
}
int main()
{
    while( ~scanf("%d%d", &n, &m) && n + m)
    {
        init();
        input();
        prim();
        solve();
        query();
    }
    return 0;
}

下面一个代码是跟着别人写的，思路差不多，但很搓，很难解释，它的做法是求出树的前序遍历，然后在数组里面实现树形DP的更新功能，以上的第一步它在询问Q外面做，第二步在询问Q里面做的,我保存其代码的原因是他树形DP的实现很犀利，然后prim用邻接表写的，我这个弱菜不会，很多地方值得学习。

#include<stdio.h>
#include<string.h>
#include<algorithm>
#include<vector>
using namespace std;

const int maxn = 3003;
const int maxm = maxn * maxn;
const int inf = 1000000000;

int n, m;
__int64 mst;
int map[maxn][maxn];
int dp[maxn][maxn], best[maxn][maxn];
int dis[maxn], pre[maxn];
bool vis[maxn];
vector<int> edge[maxn];

int minz(int a, int b)
{
    return a < b ? a : b;
}
void init()
{
    int i, j;
    for(i = 0; i < n; i++)
    {
        for(j = 0; j < n; j++)
            map[i][j] = dp[i][j] = inf;
        edge[i].clear();
        vis[i] = 0;
        pre[i] = -1;
        dis[i] = inf;
    }
}
void input()
{
    int x, y, z;
    while(m--)
    {
        scanf("%d%d%d", &x, &y, &z);
        map[x][y] = map[y][x] = z;
    }
}

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

        vis[k] = 1;
        mst += dis[k];
       //建最小生成树
        if(pre[k] != -1)
            edge[k].push_back(pre[k]),
            edge[pre[k]].push_back(k);

        for(j = 1; j < n; j++)
            if(!vis[j] && dis[j] > map[k][j] )
                dis[j] = map[k][j], pre[j] = k;
    }
}

int dfs1(int u, int fa, int rt) // 求 点rt 到 以u为根的数及其子树的最小距离
{
    int i;
    for(i = 0; i < edge[u].size(); i++)
    {
        int v = edge[u][i];
        if(v == fa) continue;
        dp[rt][u] = minz(dp[rt][u], dfs1(v, u, rt));
    }
    if(fa != rt) dp[rt][u] = minz(dp[rt][u], map[rt][u]);
    return dp[rt][u];
}

int dfs2(int u, int fa, int rt) // 求 以rt为根的数及其子树 到 以u为根的数及其子树的最小距离
{
    int i;
    int ans = dp[u][rt];
    for(i = 0; i < edge[u].size(); i++)
    {
        int v = edge[u][i];
        if(v == fa) continue;
        ans = minz(ans, dfs2(v, u, rt));
    }
    return ans;
}

void solve()
{
    int i,j;
    for(i = 0; i < n; i++)
        dfs1(i, -1, i);
    for(i = 0; i < n; i++)
        for(j = 0; j < edge[i].size(); j++)
        {
            int v = edge[i][j];
            best[i][v] = best[v][i] = dfs2(v, i, i);
        }
}
void query()
{
    int x, y, z;
    double sum = 0;
    scanf("%d", &m);
    for(int ii = 1; ii <= m; ii++)
    {
        scanf("%d%d%d", &x, &y, &z);
        if(pre[x] != y && pre[y] != x)
            sum += mst * 1.0;
        else
            sum += mst * 1.0 - map[x][y] + minz(best[x][y], z);
    }
    printf("%.4f\n", sum/m);
}
int main()
{
    while( ~scanf("%d%d", &n, &m) && n + m)
    {
        init();
        input();
        prim();
        solve();
        query();
    }
    return 0;
}

点击打开链接

方法二：

 假设两个各自连通的部分分别为树A，树B

用dp[i][j]表示树A（i点所在的树） 到 树B（j点所在的树）的最近距离。

dfs 的功能是 求树A中的点i 到 树B（j点所在的树）的最近距离，跟上面一种方法一样，对于每个 i 的dfs 复杂度是O(n) ，外加一个n的循环求出每个点，这里的总复杂度为 O(n^2)。 一边进行dfs，一边通过每一层的dfs返回值来更新dp[i][j]。  想法很犀利，代码更很犀利。

具体看代码：

#include<stdio.h>
#include<string.h>
#include<algorithm>
#include<vector>
using namespace std;

const int maxn = 3003;
const int maxm = maxn * maxn;
const int inf = 1000000000;

int n, m;
__int64 mst;
int map[maxn][maxn];
int dp[maxn][maxn];
int dis[maxn], pre[maxn];
bool vis[maxn];
vector<int> edge[maxn];

int minz(int a, int b)
{
    return a < b ? a : b;
}
void init()
{
    int i, j;
    for(i = 0; i < n; i++)
    {
        for(j = 0; j < n; j++)
            map[i][j] = dp[i][j] = inf;
        edge[i].clear();
        vis[i] = 0;
        pre[i] = -1;
        dis[i] = inf;
    }
}
void input()
{
    int x, y, z;
    while(m--)
    {
        scanf("%d%d%d", &x, &y, &z);
        map[x][y] = map[y][x] = z;
    }
}

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

        vis[k] = 1;
        mst += dis[k];

        if(pre[k] != -1)
            edge[k].push_back(pre[k]),
            edge[pre[k]].push_back(k);

        for(j = 1; 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) //求pos 点 到 以u为根的树及其子树的最小距离
{
    int i, ans = inf;
    for(i = 0; i < edge[u].size(); i++)
    {
        int v = edge[u][i];
        if(v == fa) continue;
        int tmp = dfs(pos, v, u);
        ans = minz(ans, tmp);
        dp[u][v] = dp[v][u] = minz(dp[u][v], tmp); //通过dfs的返回值来更新dp[i][j]，怎么更新自己理解吧，我也说不清楚
    }
    if(pos != fa) //保证这条边不是生成树的边， 不然不能更新
        ans = minz(ans, map[pos][u]);
    return ans;
}

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

void query()
{
    int x, y, z;
    double sum = 0;
    scanf("%d", &m);
    for(int ii = 1; ii <= m; ii++)
    {
        scanf("%d%d%d", &x, &y, &z);
        if(pre[x] != y && pre[y] != x)
            sum += mst * 1.0;
        else
            sum += mst * 1.0 - map[x][y] + minz(dp[x][y], z);
    }
    printf("%.4f\n", sum/m);
}
int main()
{
    while( ~scanf("%d%d", &n, &m) && n + m)
    {
        init();
        input();
        prim();
        solve();
        query();
    }
    return 0;
}


树形dp+MST-hdu-4126-Genghis Khan the Conqueror
cc_again的专栏
09-26 3006
题目链接： http://acm.hdu.edu.cn/showproblem.php?pid=4126 题目意思： 给一图，n个点，m条边，每条边有个花费，给出q条可疑的边，每条边有新的花费，每条可疑的边出现的概率相同，求不能经过原来可疑边（可以经过可疑边新的花费构建的边），注意每次只出现一条可疑的边，n个点相互连通的最小花费的期望。 解题思路： 树形dp+MST。 先用krus
HDU 5293 树链剖分 + 树形DP
新熊君的博客
02-03 461
题目链接题意： 给定有nn个节点的树和mm条链(链连接两个顶点，且有权值)，要求选出一部分链，使连接以后图的每个圈没有公共节点，问能够选出的链的权值和最大为多少？考虑树形DP。对于当前顶点uu，假设dp[u]dp[u]为以uu为根节点的子树所能够达到的最大目标值。 另外定义： 1.ww为当前考虑的链权值。 2.sum[u]=∑dp[k]sum[u] = \sum dp[k](kk为uu的子节
HDU 4126 Genghis Khan the Conqueror prim + 树形DP 好题
Nicolas
08-29 853
题意： 一个N个点的无向图，先生成一棵最小生成树，然后给你Q次询问，每次询问都是x,y,z的形式， 表示的意思是在原图中将x,y之间的边增大(一定是变大的)到z时，此时最小生成数的值是多少。最后求Q次询问最小生成树的平均值。 N=10000 思路： 先求出该图的最小生成树，用prim()， O(n^2)。 对于每次询问， 都是将a，b之间的边增加到c， 会出现 两种情况： 1. 如果边权
HDU - 4126 Genghis Khan the Conqueror
1262934560的博客
01-28 449
HDU - 4126 Genghis Khan the Conqueror 树形dp+MST 题目描述 Genghis Khan(成吉思汗)(1162-1227), also known by his birth name Temujin(铁木真) and temple name Taizu(元太祖), was the founder of the Mongol Empire and the gr...
HDU 4126 Genghis Khan the Conqueror
qq_43544481的博客
01-20 169
题意： 给你n个点，m条边的图，有Q次询问，每次询问输入u,v,w,表示将u->v的边权替换成w后（w一定不小于替换前的值），最小生成树的权值和为多少，求Q次询问的平均值（替换只在当前询问有效） 题解： 可以先处理出MST，考虑每次替换的边是否在MST中，首先如果不在MST中肯定是最简单的，MST的权值和不变，所以我们只需要考虑添加的边在MST中的情况。容易想到，如果在MST中，那么将这条...
hdu3899 JLUCPC--树形dp（好题）
半壶老酒
10-22 677
原题链接：http://acm.hdu.edu.cn/showproblem.php?pid=3899 题意： 给定n个点，每个点的人数，n-1条边和边权。选取任意一点u，然后让所有人都移动到u点，问最小的移动距离和是多少。 分析： 注意数字比较大，用long long，递归深度较大，用了#pragma comment(linker, "/STACK:102400000
Hdu2196-Computer （树形dp）（经典题）
Stupid_Turtle的博客
12-20 615
传送门：Computer 题意：有 n 个点，通过 n-1 条边连成一棵树，每条边有一个权值，求从每个点出发的简单路径的最大长度。 思路：树形dp 首先以 1 为根建树，这样每个点能走的最大路径有两种情况：往下沿着子节点走或往上沿着父结点走。假设根节点为 rt，我们定义： dp[rt][0] 表示以 rt 为根的子树上的节点到 rt 的最长距离。 dp[rt][1] 表示以 rt 为根的...
HDU 5909 Tree Cutting 树形DP+快速沃尔什变换
世界
10-14 2999
题目大意：给出一棵树，每个点有一个点权，求对于每个i∈[0,m)i\in[0,m)输出有多少个连通诱导子图的异或和为ii n≤1000n\leq1000，m<210m<2^{10}别问我为什么隔了这么久突然跑回来更blog……我只是在填以前剩下的坑而已。。。 (我花了一整个高三去打游戏，然后花了一整个大一补高三的内容，到了大二，我退学了2333)FWT定义： 对于一个长为n=2kn=2^k的数
HDU 2196 Computer（树形dp）
最新发布
鱼香rose_的博客
05-22 1508
HDU2196Computer（树形dp） 给出一个n个节点的无根树，求每个节点所能到达的最远距离。
HDU4126Genghis Khan the Conqueror(最小生成树+并查集)
青山绿水之辈 专栏
03-20 1492
Genghis Khan the Conqueror Time Limit: 10000/5000 MS (Java/Others)    Memory Limit: 327680/327680 K (Java/Others) Total Submission(s): 1687    Accepted Submission(s): 501 Problem Description G
HDU 2196【树形dp*好题】
王小二的博客
11-08 343
A school bought the first computer some time ago(so this computer's id is 1). During the recent years the school bought N-1 new computers. Each new computer was connected to one of settled earlier. Ma
HDU 4126 Genghis Khan the Conqueror（最小生成树）
AC_Arthur的专栏
03-05 1306
题目链接：点击打开链接 题意：给你一张图， n个点， m条边， 求一个最小生成树， 然后Q个询问， 每个询问要求改变一条边， 然后求现在的最小生成树。 思路：最暴力的做法是， 对于每个询问， 改变这个边（一定是增大）之后再做一遍最小生成树。 复杂度O(qm)，显然会超时。 那么我们可以发现， 对于每个询问推一步的结果如下： 1. 改变的这条边不在最小生成树中， 那么答案就是最小生成树。 2
HDU 4126 Genghis Khan the Conqueror （树形DP + MST）
Tongqi
11-18 655
题目链接：http://acm.hdu.edu.cn/showproblem.php?pid=4126 题意：给n个点，m条边，每条边权值c，现在要使这n个点连通。现在已知某条边要发生突变，再给q个三元组，每个三元组(a,b,c)，(a,b)表示图中可能发生突变的边，该边一定是图中的边。c表示该边新的权值，c只可能比原来的权值大。给的q条边发生突变的概率是一样的。求突变后连通n个点最小代价...
hdu 4126 Genghis Khan the Conqueror (MST+树形dp)
To be what you what to be!
09-27 1880
Genghis Khan the Conqueror Time Limit: 10000/5000 MS (Java/Others)    Memory Limit: 327680/327680 K (Java/Others) Total Submission(s): 1208    Accepted Submission(s): 332 Problem Descript
HDU 5593 ZYB's Tree(树形DP 好题（java）)
kalilili的专栏
12-05 855
大致题意： 有n = 500000节点的树， 对于每个节点求距离此节点不超过K (K 思路： 题意中的边是通过 “For reading:we have two numbers A and B,let fai be the father of node i,fa1=0,fai=(A∗i+B)%(i−1)+1 for i∈[2,N] .”  这样构造出来的，这只是便于快速读入而已，
hdu-4126 Genghis Khan the Conqueror(最小生成树+树形dp)
weixin_30815427的博客
04-13 157
题目链接： Genghis Khan the Conqueror Time Limit: 10000/5000 MS (Java/Others) Memory Limit: 327680/327680 K (Java/Others) Problem Description Genghis Khan(成吉思汗)(1162-1227), also known by his birth ...
hdu4126Genghis Khan the Conqueror (最小生成树+树形dp)
新月
09-22 847
Time Limit: 10000/5000 MS (Java/Others)    Memory Limit: 327680/327680 K (Java/Others) Total Submission(s): 2524    Accepted Submission(s): 760 Problem Description Genghis Khan(成吉思汗)(1162-1
hdu4126.Genghis Khan the Conqueror
Grastyele
12-02 2279
http://acm.hdu.edu.cn/showproblem.php?pid=4126 题意：给一个图（V 思路：一个不知道怎么证的引用：新的生成树可以与原生成树相最多只有一条边的不同，而且不同的那条边就是被修改的边。那么每次修改后的询问就是去掉被修改的边，然后求出两个树最近的点。又有其中一棵子树一定包含他所有的子节点，那么就可以先用树dp求出一个点与一棵子树的最小距离，即求出dp[i]
HDU题库源码分享：600+编程题目解决方案
6. 25792.cpp和25791.cpp: 这些编号较高的题目可能指代的是较为复杂的算法问题，如涉及高级数据结构和算法的应用，比如线段树、树状数组、高级搜索策略等。 7. 10074.cpp: 编号10074可能指向的是一道图论问题，图论...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值