ACM 暑期培训——最短路/最小生成树专题

最新推荐文章于 2021-07-09 19:00:55 发布
最新推荐文章于 2021-07-09 19:00:55 发布
阅读量500 收藏
点赞数
CC 4.0 BY-SA版权
分类专栏： 图论
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/tyh24689/article/details/38024371
本文深入探讨了深度学习在人工智能领域的应用，包括图像处理、音视频处理、自然语言处理等多个方面，详细介绍了相关算法和技术的原理、实现及实际案例。

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

A. HDU1142  Walk Through the Forest 

单源最短路径+记忆化搜索。

#include <algorithm>
#include <cstdio>
#include <cstdlib>
#include <cmath>
#include <cstring>
#include <iostream>
#define INF 10000000
using namespace std;
int G[1005][1005],dis[1005],vis[1005];
int dp[1005];
int n;
void dijk(int s)
{
    int i,j;
    for(i=1; i<=n; i++)
    {
        vis[i]=0;
        dis[i]=G[s][i];
    }
    vis[s]=1;
    for(i=1; i<=n; i++)
    {
        int MIN=INF,f=0;
        for(j=1; j<=n; j++) if(!vis[j])
                if(dis[j]<MIN) MIN=dis[j],f=j;
        vis[f]=1;
        for(j=1; j<=n; j++) if(!vis[j])
            dis[j]=min(dis[j],MIN+G[f][j]);
    }
    return ;
}
int dfs(int x)
{
    if(dp[x]!=-1) return dp[x];
    dp[x]=0;
    for(int i=1;i<=n;i++)
    {
        if(G[x][i]<INF&&dis[x]>dis[i])
            dp[x]+=dfs(i);
    }
    return dp[x];
}
int main()
{
    int m,s,d,x,y,v,i,j;
    while(~scanf("%d",&n)&&n)
    {
        scanf("%d",&m);

        for(i=0;i<=n;i++)
            for(j=0;j<=n;j++)
                G[i][j]=i==j?0:INF;

        for(i=0;i<m;i++)
        {
            scanf("%d%d%d",&x,&y,&v);
            G[y][x]=G[x][y]=v;
        }
        dijk(2);
        memset(dp,-1,sizeof(dp));
        dp[2]=1;
        dfs(1);
        printf("%d\n",dp[1]);
    }
    return 0;
}



B.一个人的旅行 HDU2066

单源最短路径，对于他家相连的城市直接把距离设为0即可。注意有重边。

#include <algorithm>
#include <cstdio>
#include <cstdlib>
#include <cmath>
#include <cstring>
#include <iostream>
#define INF 10000000
using namespace std;
int G[1005][1005],dis[1005],vis[1005];
int n=1005;
void dijk(int s)
{
    int i,j;
    for(i=0; i<n; i++)
    {
        vis[i]=0;
        dis[i]=G[s][i];
    }
    vis[0]=1;
    for(i=0; i<n; i++)
    {
        int MIN=INF,f=0;
        for(j=0; j<n; j++) if(!vis[j])
                if(dis[j]<MIN) MIN=dis[j],f=j;
        vis[f]=1;
        for(j=0; j<n; j++) if(!vis[j])
            dis[j]=min(dis[j],MIN+G[f][j]);
    }
    return ;
}
int main()
{
    int m,s,d,x,y,v,i,j;
    while(~scanf("%d%d%d",&m,&s,&d))
    {
        int ans=INF;
        for(i=0; i<n; i++)
            for(j=0; j<n; j++)
                G[i][j]= i==j?0:INF;
        for(i=0; i<m; i++)
        {
            scanf("%d%d%d",&x,&y,&v);
            G[y][x]=G[x][y]=min(v,G[x][y]);
        }
        for(i=0; i<s; i++)
        {
            scanf("%d",&x);
            G[0][x]=0;
        }
        dijk(0);
        for(i=0;i<d;i++)
        {
            scanf("%d",&x);
            ans=min(ans,dis[x]);
        }
        printf("%d\n",ans);
    }

    return 0;
}

C - Minimum Transport Cost  HDU1385

Floyd多源最短路径，而且要按照路径输出。

其实Floyd最短路是基于DP思想的。首先要理解它的状态表示方式和状态转移方程。

而且路径输出要求在距离相同时输出字典序最小的路径，所以要处理一下。

#include <algorithm>
#include <cstdio>
#include <cstdlib>
#include <cmath>
#include <cstring>
#include <iostream>
#define INF 10000000
using namespace std;
int G[1005][1005];
int pre[1005][1005];
int dis[1005][1005];
int tax[1005];
int n;
void floyd()
{
    int i,j,k;
    for (i=0; i<n; i++)
        for (j=0; j<n; j++)
            dis[i][j]=G[i][j],pre[i][j]=j;
    for (k=0; k<n; k++)
        for (i=0; i<n; i++)
            for (j=0; j<n; j++)
            {
                if(dis[i][k]>=INF||dis[k][j]>=INF) continue;
                int t=dis[i][k]+dis[k][j]+tax[k];
                if(t<dis[i][j])
                {
                    dis[i][j]=t;
                    pre[i][j]=pre[i][k];
                }
                else if(t==dis[i][j])
                {
                    pre[i][j]=min(pre[i][j],pre[i][k]);
                }
            }
}
int main()
{
    int d,i,j;
    while(scanf("%d",&n)!=EOF&&n)
    {
        for(i=0; i<n; i++)
            for(j=0; j<n; j++)
            {
                scanf("%d",&d);
                if(d==-1) G[i][j]=INF;
                else G[i][j]=d;
            }
        for(i=0;i<n;i++)
            scanf("%d",&tax[i]);
        floyd();
        int a,b;
        while(scanf("%d%d",&a,&b)&&a+b>0)
        {
            int t=a-1;
            printf("From %d to %d :\n",a,b);
            printf("Path: %d",a);
            while(t+1!=b)
            {
                t=pre[t][b-1];
                printf("-->%d",t+1);
            }
            printf("\nTotal cost : %d\n\n",dis[a-1][b-1]);
        }
    }

    return 0;
}

D - Minimal Ratio Tree HDU2489

给你n个点 (n<15)，从中取m个，组成一棵树，并且使得 （所有边权值之和 / 所有点权值之和）最小。

n是非常小的，所以可以用深搜枚举所有的可能的组合。

在所有组合中取最小值。

#include <algorithm>
#include <iostream>
#include <cstdio>
#include <cstring>
#include <cmath>
#include <cstdlib>
#define INF 0x7fffffff
using namespace std;
int n,m;
bool choose[20];
bool vis[20];
int dis[20];
int w[20],G[20][20];
int q[20];
double ans;
int prim(int s)
{
    int i,j;
    int sum=0;
    for(i=0; i<n; i++)
    {
        dis[i]=G[i][s];
        if(choose[i]) vis[i]=0;
        else vis[i]=1;
    }
    vis[s]=1;
    for(i=1; i<m; i++)
    {
        int MIN=INF,f=0;
        for(j=0; j<n; j++)
            if(!vis[j]&&dis[j]<MIN) f=j,MIN=dis[j];
        vis[f]=1;
        sum+=MIN;
        for(j=0; j<n; j++) if(!vis[j])
                dis[j]=min(dis[j],G[f][j]);
    }
    return sum;
}
void dfs(int last,int t)
{
    if(t==m)
    {
        double sum_node=0;
        for(int i=0; i<n; i++) if(choose[i])
                sum_node+=w[i];
        int sum_edge=prim(last);
        double rat=sum_edge*1.0/sum_node;
        if(ans>rat)
        {
            ans=rat;
            for(int k=0,i=0; i<n; i++) if(choose[i])
                    q[k++]=i;
        }
    }
    for(int i=last; i<n; i++) if(!choose[i])
        {
            choose[i]=1;
            dfs(i,t+1);
            choose[i]=0;
        }
}
int main()
{
    int x,i,j;
    while(scanf("%d%d",&n,&m)!=EOF&&m+n)
    {
        ans=1e10;
        memset(choose,0,sizeof(choose));
        for(i=0; i<n; i++)
            scanf("%d",&w[i]);
        for(i=0; i<n; i++)
            for(j=0; j<n; j++)
            {
                scanf("%d",&x);
                G[i][j]=x;
            }
        dfs(0,0);
        for(i=0; i<m-1; i++)
            printf("%d ",q[i]+1);
        printf("%d\n",q[i]+1);
    }
    return 0;
}

E - Slim Span

题目给出n个点，m条边，要求组成一棵树并且使得 最大边与最小边尽量接近。

很容易想到用kruskal，在最短边确定的情况下，依据贪心的方法，所得的最小生成树的最大边也是尽量小的。

排序后取最小的一条边作为最短边，进行一次kruskal。

依次枚举每条边作为最短边，进行kurskal，最后取最大边与最小边最接近的即可。

#include <algorithm>
#include <cstdio>
#include <cstdlib>
#include <cmath>
#include <cstring>
#include <iostream>
#define INF 0x7fffffff
using namespace std;
int a[1005];
struct node
{
    int x,y,w;
}e[100004];
int cmp(node a ,node b)
{
    return a.w<b.w;
}
int Find(int x)
{
    if(x!=a[x]) return a[x]=Find(a[x]);
    else return x;
}
int main()
{
    int n,m,i,j;
    while(scanf("%d%d",&n,&m)!=EOF&&m+n)
    {
        for(i=0;i<m;i++)
            scanf("%d%d%d",&e[i].x,&e[i].y,&e[i].w);
        sort(e,e+m,cmp);
        int ans=INF;
        for(j=0;j<m;j++)
        {
            int cnt=0,L=INF,R=0;
            for(i=0;i<=n;i++)
                a[i]=i;
            for(i=j;i<m;i++)
            {
                int x=Find(e[i].x),y=Find(e[i].y);
                if(x!=y)
                {
                    a[x]=y;
                    cnt++;
                    L=min(L,e[i].w);
                    R=max(R,e[i].w);
                }
                if(cnt==n-1) break;
            }
            if(cnt==n-1) ans=min(ans,R-L);
        }
        if(ans!=INF) printf("%d\n",ans);
        else printf("-1\n");

    }

    return 0;
}



F - Highways  poj1751

最小生成树，但是要输出在生成树过程中添加的边。

用prim算法，只要在其中加一个数组记录当前点与生成树中距离最近的点。 比如 dis_p[2]=1, 表示 树外一点 2 , 距离最近的树内的点为 1.

所以每次更新dis的时候同时更新dis_p即可。

#include <algorithm>
#include <cstdio>
#include <cstdlib>
#include <cmath>
#include <cstring>
#include <iostream>
#define INF 0x7fffffff
using namespace std;
int x[1005];
int y[1005];
bool vis[1005];
int dis[1005];
int dis_p[1005];
int G[1005][1005];
struct node
{
    int x,y;
    int dis;
}ans[1005];
int getdis(int a,int b)
{
    return (x[a]-x[b])*(x[a]-x[b])+(y[a]-y[b])*(y[a]-y[b]);
}
int main()
{
    int n,m,i,j;
    while(~scanf("%d",&n))
    {
        for(i=0;i<n;i++)
            scanf("%d%d",&x[i],&y[i]);
        for(i=0;i<n;i++)
            for(j=i;j<n;j++)
            {
                if(j==i) G[i][j]=0;
                else G[i][j]=G[j][i]=getdis(i,j);
            }
        scanf("%d",&m);
        for(i=0;i<m;i++)
        {
            int a,b;
            scanf("%d%d",&a,&b);
            G[a-1][b-1]=G[b-1][a-1]=0;
        }
        memset(vis,0,sizeof(vis));
        for(i=0;i<n;i++) dis[i]=G[i][0],dis_p[i]=0;
        vis[0]=1;
        for(i=1;i<n;i++)
        {
            int MIN=INF,f=0;
            for(j=0;j<n;j++)
                if(!vis[j]&&dis[j]<MIN) MIN=dis[j],f=j;
            vis[f]=1;
            if(MIN!=0) printf("%d %d\n",dis_p[f]+1,f+1);
            for(j=0;j<n;j++) if(!vis[j])
                if(dis[j]>G[f][j]) dis[j]=G[f][j],dis_p[j]=f;
        }
    }

    return 0;
}




ACM:prim最小生成树题目汇总
EmilSinclair4391的博客
05-03 1430
1.http://115.28.138.223/view.page?gpid=T18import java.util.Scanner; public class Main{ static final int MAX=Integer.MAX_VALUE; public static void main(String[] args){ Scanner input=new
ACM／ICPC 金牌进阶之路
git1314的博客
06-06 4967
大一 上学期 1、熟练掌握 C 语言 2、基础算法与数据结构 （枚举、贪心、递归、分治、模拟、搜索、队列、栈、链表、最短路、最小生成树、基础组合数学、基础数论、二分求解单调性问题、背包问题等） 3、OJ 题量达到 150 题 寒假作业：使用 C 语言写一个贪吃蛇小游戏并答辩 下学期 1、熟练掌握 C++ 语言（类及 STL） 2、基础算法与数据结构 （构造、拓扑排序、二分...
acm专题学习之生成树（二）次小生成树+HDU-4081
qq_40306845的博客
02-16 337
题目：秦始皇想要修路，他只想着修总长度最小（最小生成树）。但有个道士告诉他，可以用魔法修一条路，不耗费人力财力的一条魔法路。秦始皇想要使非魔法道路总长度尽可能小，道士希望尽可能多的人受益。最终决定：修魔法路的两个城市，（两个城市的总人口）/（非魔法道路总长度）必须是最大。 输入：t个测试数据，n个城市，每个城市输入为坐标（x，y）和人口p 输出：（两个城市的总人口）/（非魔法道路总长度）最大值...
北大2018acm暑期课六最短路&&最小生成树
叶子心情你不懂
08-02 278
Candies 描述 During the kindergarten days, flymouse was the monitor of his class. Occasionally the head-teacher brought the kids of flymouse’s class a large bag of candies and had flymouse distribute ...
sduacm2016级暑假集训 最短路&最小生成树
ProboxDu的博客
07-21 283
比赛地址 密码：acm2016 A - 畅通工程 (HDU1863)题目链接 【题意】 问题意中给出的图是否能求出一颗最小生成树，若不能求出输出？否则输出最小生成树权值。 【分析】 简单的最小生成树模板题。 【Code】#include<cstdio> #include<cstring> #include<algorithm> using namespace std; #defin
ACM训练史上最详细计划（大神养成记）
热门推荐
qq_40688707的博客
06-06 6万+
看完人家的博客，发现任重道远。。。一位高手对我的建议：一般要做到50行以内的程序不用调试、100行以内的二分钟内调试成功.acm主要是考算法的，主要时间是花在思考算法上，不是花在写程序与debug上。 下面给个计划你练练：第一阶段：练经典常用算法，下面的每个算法给我打上十到二十遍，同时自己精简代码，因为太常用，所以要练到写时不用想，10-15分钟内打完，甚至关掉显示器都可以把程序打出来. 1.最短...
（实习替代）2021ACM培训摸底（主席树、旋转卡壳等）——2021-07-09
I_have_a_world的博客
07-09 221
自闭传送门 难度判断？ 总结收获： 好好补题，查漏补缺。我相信，认真对待这次暑期培训，我能学到很多东西。 补题以提高思维能力（想当时没想明白的题），算法能力（学新算法）为主。不必每个题都一样程度的仔细总结 题目： 1. A - 橡皮球 51Nod - 1247 题意：二维平面，如果某点位置为(a,b)，下一步可以跳到(a+b, b), (a-b, b), (a,a+b), (a,a-b)之一。输入a,b,x,y，判断是否能从(a,b)跳到(x,y)（可以跳任意次），1 <= a, b,
2020ACM暑期集训 框架（暑期不断更新）
Alanrookie的博客
07-04 915
暑期联谊集训 框架第一周 C++/二分双指针单调栈/简单搜索第二周 简单数据结构/kmp/字典树 第一周 C++/二分双指针单调栈/简单搜索 C++STL/JavaAPI (这一块基本都学过了，这两天直接练题比赛) 二分尺取单调栈 推荐视频: y总的二分. 推荐视频: 双指针单调栈. ———————————————————— 推荐博客: 二分查找. 推荐博客: 尺取（双指针）. 推荐博客: 单调栈. 简单搜索 推荐视频: 北理DFS BFS. ———————————————————— 推荐博客: 搜索（B
ACM北大暑期课培训第六天
weixin_33758863的博客
07-30 298
　　今天讲了DFA，最小生成树以及最短路 　　DFA（接着昨天讲） 　　如何高效的构造前缀指针： 　　步骤为：根据深度一一求出每一个节点的前缀指针。对于当前节点，设他的父节点与他的边上的字符为Ch，如果他的父节点的前缀指针所指向的节点的儿子中，有通过Ch字符指向的儿子，那么当前节点的前缀指针指向该儿子节点，否则通过当前节点的父节点的前缀指针所指向点的前缀指针，继续向上查找，直到到达根节...
北京大学ACM暑期课课件
07-19
7.15 若干图论问题：最小生成树 最短路 强连通分量、桥和割点 等 7.16 网络流算法：基本的网络流算法，Dinic算法，带上下界的网络流，最小费用流 7.17 数学题：组合数学，数论等 7.18 最小生成树和动态规划
UESTC的ACM题目推荐
05-13
从最短路、最小生成树到最大流，从并查集、快速查找再到数论、线段树，每个类别都包含了至少几个题目，覆盖了算法的多个层面。这些题目不仅考验着对特定算法的理解，也要求学习者具备将理论应用于实际问题的能力。 ...
ACM比赛经验、刷题记录及模板库总结（更新中）
lordofadventure的博客
03-08 2138
文章目录前言第一部分 经验分享及感受第二部分 刷题记录一、基础算法&程序语言二、综合题（现场题）三、动态规划四、图论五、字符串算法六、数据结构七、数学八、网络流九、博弈十、随机算法十一、其他第三部分 专项题库第四部分 模板库附录A 题目索引附录B 常用平台参考文献 前言 本文所提及的部分题目代码，可以在https://github.com/volactina/ACM上找到 第一部分 经验分...
HDU5294——Tricks Device（最短路 + 最大流）
Reverie
07-21 1092
第一次做最大流的题目… 这题就是堆模板#include <iostream> #include <algorithm> #include <cmath> #include <cstring> #include <cstdio> #include <cstdlib> #include <vector> #include <queue> using namespace std;typedef long
CF507E——Breaking Good(BFS,DP)
Reverie
01-24 937
507E Breaking Good dfs and similar, graphs, shortest paths    x328 题意：给你一些道路，道路长度都为1，道路有两个状态可用和不可用。 寻找一条1到N的最短路，使得该最短路上的道路全部可用，其他道路全部不可用，要求改变状态的道路数量尽量小。 分析：1-N的最短路的长度一定
拓扑排序学习
Reverie
06-01 737
其实早就对拓扑排序觊觎已久
解题报告之——hdu1233还是畅通工程（最小生成树）
Reverie
01-22 648
Description 某省调查乡村交通状况，得到的统计表中列出了任意两村庄间的距离。省政府“畅通工程”的目标是使全省任何两个村庄间都可以实现公路交通（但不一定有直接的公路相连，只要能间接通过公路可达即可），并要求铺设的公路总长度为最小。请计算最小的公路总长度。    Input 测试输入包含若干测试用例。每个测试用例的第1行给出村庄数目N ( 当N为0时，
最短路模板——dijkstra,SPFA(邻接表实现)
Reverie
08-09 642
#include #include #include #include #include #include #include #include using namespace std; typedef long long LL; const int INF = 1e8; const int N = 1000 + 10; struct Edge { int v,w;
POJ1182——食物链（种类并差集）
Reverie
06-29 455
非常经典的并查集。 关键是
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值