最短路总结--模板及例题

最新推荐文章于 2024-08-01 20:08:39 发布
最新推荐文章于 2024-08-01 20:08:39 发布
阅读量834 收藏 6
点赞数 3
CC 4.0 BY-SA版权
分类专栏： 总结 图论 STL 文章标签： 图论 stl
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Gank_Wind/article/details/107674862
本文总结了图论中的四种经典最短路算法：Floyd、Dijkstra、Bellman-Ford和SPFA。Floyd适用于解决任意两点间最短路，Dijkstra适合单源点最短路，但无法处理负权；Bellman-Ford能处理负权，但可能有负环问题；SPFA是Bellman-Ford的优化，但比赛中易被卡。

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

前言

最短路是图论中的一种常见题目，通常用邻接表和邻接矩阵来储存，用邻接矩阵存可能会因为空间超大而不可取，但更加方便，具体选择要根据题目要求来

1.Floyd算法

弗洛伊德（floyd）算法是一种用来解决任意两点之间的最短路的算法，以动态规划的思路来进行遍历

我们定义一个数组dp[k][i][j]来表示第i个点到第j个点的小于等于点k标号的中转点时的最短路，如果从i到k再从k到j的两条路之和比目前从i到j的最短路更短，那么就更新dp[k][i][j]
如
在这里插入图片描述

	for(int k=1;k<=n;k++)
	{
		for(int i=1;i<=n;i++)
		{
			for(int j=1;j<=n;j++){
				if(G[k][i][j]>G[k-1][i][k]+G[k-1][k][j])
				{
					G[k][i][j]=G[k-1][i][k]+G[k-1][k][j];
				}
			}
		}
	}

同时，因为第k个点总是由k-1个点的来，所以第一位可以省略变为如下代码

	for(int k=1;k<=n;k++)
	{
		for(int i=1;i<=n;i++)
		{
			for(int j=1;j<=n;j++){
				if(G[i][j]>G[i][k]+G[k][j])
				{
					G[i][j]=G[i][k]+G[k][j];
				}
			}
		}
	}

在输出路径时，可以用一个数组来记录当前点的前驱，最后递归输出即可
例题
因为数据较小，所以用 f l o y d floyd floyd也可以解决

#include<cstdio>
#include<iostream>
using namespace std;
int G[505][505],prev[505][505],n,m,s,e;
void print(int x)//递归输出
{
	if (prev[s][x]==0) {//如果已经枚举到了s点
		printf("%d",s);//输出s
		return ;//退出
	}
	print(prev[s][x]);//否则就递归
	printf(" %d",x);//输出上一个点的前驱
}
int main()
{
	scanf("%d%d",&n,&m);
	for(int i=1;i<=n;i++)
	{
		for(int j=1;j<=n;j++)
	    {
	    	G[i][j]=0x3f3f3f3f;//把没有连接的两个点的距离赋为无穷大
		}
		G[i][i]=0;
		prev[i][i]=0;
	}
	for(int i=1;i<=m;i++)
	{
		int x,y,w;
		scanf("%d%d%d",&x,&y,&w);
		G[x][y]=w;	
		prev[x][y]=x;//y的前驱为x
   }
	for(int k=1;k<=n;k++)
	{
		for(int i=1;i<=n;i++)
		{
			for(int j=1;j<=n;j++){
				if(G[i][j]>G[i][k]+G[k][j])//如果有更短的路
				{
					G[i][j]=G[i][k]+G[k][j];//更新路的长度
					prev[i][j]=prev[k][j];//更新前驱，注意，这里不能直接赋为k，因为k是枚举1到n任意的一个点，可能不是j的前驱
				}
			}
		}
	}
	scanf("%d%d",&s,&e);
	printf("%d\n",G[s][e]);//输出最短路
	print(e);//输出路径
	return 0;
}

赠加:无向图的最小环问题
题目大意:给定一个无向图,寻找最小环的权值之和
从题目中可以发现一看到n<=100直接无脑floyd,我们枚举到k点时,前面的k-1个点的最小值都已经更新,那么从前面的k-1个点中枚举两个点i,j来更新最小环的权值(长度最小的环由k和与之相连的i,j组成,要找更长的环,其实就是i或j的最短路加上那个点到i或j的最短路,所以只用枚举i,j即可)
然后再更新一下最短路就行了

#include<cstdio>
#include<iostream>
using namespace std;
const int inf=0x3f3f3f3f;
int n,m,ans=inf,dis[150][150],a[150][150];
int main()
{
	scanf("%d%d",&n,&m);
	for(int i=1;i<=n;i++)
	{
		for(int j=1;j<=n;j++)
		{
			dis[i][j]=0x3f3f3f3f;
			a[i][j]=0x3f3f3f3f;
		}
		a[i][i]=0;
		dis[i][i]=0;
	}
	for(int i=1;i<=m;i++)
	{
		int u,v,w;
		scanf("%d%d%d",&u,&v,&w);
		dis[u][v]=min(dis[u][v],w);//判断重环
		dis[v][u]=min(dis[v][u],w);//判断重环
		a[u][v]=min(a[u][v],w);//判断重环
		a[v][u]=min(a[v][u],w);//判断重环
	}
	for(int k=1;k<=n;k++)
	{
		for(int i=1;i<k;i++)
		{
			for(int j=i+1;j<k;j++)
			{
				ans=min(ans,dis[i][j]+a[i][k]+a[k][j]);//更新最小环的权值和
			}
		}
		for(int i=1;i<=n;i++)
		{
			for(int j=1;j<=n;j++)
			{
				dis[i][j]=min(dis[i][j],dis[i][k]+dis[k][j]);//更新最短路
				dis[j][i]=dis[i][j];
			}
		}
	}
	if(ans==inf)
	{
		printf("No solution.");
		return 0;
	}
	printf("%d\n",ans);
	return 0;
}

2.dijkstra算法

迪杰斯特拉（dijkstra）算法是求指定起点（单源点）的最短路问题的常用办法，思想有点类似于bfs
dijstra算法的原理是先把所有点的距离赋为最大值，然后通过从当前起点开始，暴力枚举与其相邻且未被访问过的结点，算出这些边中的最小值，将起点赋为那个结点，标记为已访问，再进行操作，直到找到终点到起点的最短路，在四种算法中最常用，但是无法跑负权图

其中，一种被称为”松弛操作“的技巧常用于dijkstra算法当中，思想就是：如果从一个点的前驱走到此时我们找到的点再走到这个点，离源点的距离比目前这个点的最短路更小，就把它的值修改成上述情况（就像把一根绳子拉的更松，距离更短）

	for(int j=1;j<=n;j++)
		{
		dis[j]=min(dis[j],dis[k]+w[k][j]);//k为目前离源点最近的结点
		}

例题

#include<cstdio>
#include<iostream>
#include<cstring>
using namespace std;
int n,m,dis[2505],w[2505][2505],s,e;
bool vis[2505];
void dijkstra()
{ 
    memset(vis,0,sizeof(vis));
    memset(dis,0x3f,sizeof(dis));
    dis[s]=0;
	for(int i=1;i<=n-1;i++)//枚举所有的结点
    {
    	int k=0;
    	for(int j=1;j<=n;j++)
    	{
            if(!vis[j]&&(k==0||dis[j]<dis[k]))//如果没有被访问过并且距离更短
            {
            	k=j;//更新为结点j
			}
		}
		if(!k)//如果已经被访问过
		{
			continue;
		}
		vis[k]=1;//k标记为已走
		for(int j=1;j<=n;j++)
		{
		dis[j]=min(dis[j],dis[k]+w[k][j]);//“松弛”操作
		}
	}
}
int main()
{
	scanf("%d%d%d%d",&n,&m,&s,&e);
	memset(w,0x3f,sizeof(w));
	for(int i=1;i<=n;i++)
	{
		w[i][i]=0; 
	}
	for(int i=1;i<=m;i++)
	{
		int x,y,zhi;
		scanf("%d%d%d",&x,&y,&zhi);
	    w[x][y]=min(w[x][y],zhi);//x到y的距离
		w[y][x]=w[x][y];//无向图是双向边
	}
    dijkstra();
    printf("%d\n",dis[e]);
    return 0;
}

优先队列优化版

#include <queue>
#include <cstdio>
#include <vector>
#include <cstring>
#include <algorithm>
#define ll long long
using namespace std;

const int MAXN = 2505;
int n, m, s, t;
int vis[MAXN], dis[MAXN];

struct edge {
    int v;
    int w;
    edge() {}
    edge(int V, int W) { v = V, w = W; }
};

struct node {
    int u;
    int dis;
    node() {}
    node(int U, int D) { u = U, dis = D; }
    friend bool operator < (node x, node y) { return x.dis > y.dis; }
};

vector<edge> G[MAXN];

int dijkstra(int S, int T) {
    memset(dis, 0x3f, sizeof dis);
    priority_queue < node > Q;
    dis[S] = 0;
    Q.push(node(S, 0));
    while (!Q.empty()) {
        int u = Q.top().u;
        Q.pop();
        if (vis[u]) continue;
        vis[u] = 1;
        for (int i = 0, v, w; i < G[u].size(); i++) {
            v = G[u][i].v, w = G[u][i].w;
            if (dis[v] > dis[u] + w) {
                dis[v] = dis[u] + w;
                Q.push(node(v, dis[v]));
            }
        }
    }
    return dis[T];
}

int main() {
    scanf("%d %d %d %d", &n, &m, &s, &t);
    for (int i = 1; i <= m; i++) {
        int u, v, w;
        scanf("%d %d %d", &u, &v, &w);
        G[u].push_back(edge(v, w));
        G[v].push_back(edge(u, w));
    }
    printf("%d", dijkstra(s, t));
    return 0;
}

为什么dijkstra算法不能跑负权值呢？
如下面这张图
在这里插入图片描述

按照我们的思路，结果会先从上方遍历1-2-3的结点，总长为1+2=3.但是，从下面走的路径是3-100=-97！明显比3更小，所以当出现负权值时，dijkstra算法是处理不了的。否则还要Bellman和SPFA干什么

Bellman-Ford算法

贝尔曼福特（Bellman-Ford）是另一种用来解决单源点最短路的算法，思想是对所有点进行“松弛操作”，可以用在出现负权的图中，但是如果存在负环，环中的边权会被松弛地越来越小，所以再用一层循环来判断是否有边仍然不满足三角形不等式（用来松弛的两边大于备松弛的边），如果存在，那么就有负环
路径输出和floyd同理

用两重循环，第一重循环枚举点的个数-1（起点不包括），第二重枚举边的数量，将所有边进行松弛，最后再判断负环。特别的，如果一个点的起点就是源点，它到源点的最短路就是它的边权
例题

#include<cstdio>
#include<iostream>
#include<cstring>
using namespace std;
int n,m,s,t,dis[50005],prev[50005];
struct ren{
	int u,v,w;
}a[50005];
void print(int x)//路径输出
{
	if(!prev[x])//如果已经到了原点
	{
		printf("%d",s);
		return;
	}
	print(prev[x]);
	printf(" %d",x);
}
bool bellmanford(int s)
{	
    memset(dis,0x3f,sizeof(dis));
	for(int i=1;i<=m;i++)
	{
		if(a[i].u==s)
		{
			dis[a[i].v]=a[i].w;
		}
	}
	for(int i=1;i<=n-1;i++)//对全部边进行松弛
	{
		for(int j=1;j<=m;j++)
		{
	        if(dis[a[j].v]>dis[a[j].u]+a[j].w)
	        {
	        	dis[a[j].v]=dis[a[j].u]+a[j].w;
	        	prev[a[j].v]=a[j].u;//改变前驱
			}
		}
	}
		for(int j=1;j<=m;j++)//判断负环
		{
			if(dis[a[j].v]>dis[a[j].u]+a[j].w)
			{
				return false;
			    break;
			}
		}
		return true;
}
int main()
{

	scanf("%d%d",&n,&m);
	for(int i=1;i<=m;i++)
	{
		scanf("%d%d%d",&a[i].u,&a[i].v,&a[i].w);
		prev[a[i].v]=a[i].u;
	}
	scanf("%d%d",&s,&t);
	prev[s]=0;
	dis[s]=0;
	if(!bellmanford(s))//有负环
	{
	    printf("No Solution\n");
	}
	else{
		printf("%d\n",dis[t]);
		print(t); 
	}
	return 0;
}

但是bellman有个很大的问题在于它有可能去松弛的边很多都是无用的，如果输入顺序是从终点到起点，那么bellman需要跑两次m才能松弛完所有边，并且有的边可能根本和终点没有关系，大大地损耗了时间，所以才会诞生SPFA算法

SPFA算法

SPFA其实就是贝尔曼福特算法的队列优化，每次只取出与这个点相邻接的点进行松弛，判断负环的方法就是计算每个点入队的次数，一个点在无负环的情况下最多与所有其他点相连，最多入队n次，如果次数大于了n，说明它在负环内，返回false

请注意，SPFA在很多比赛中容易被卡，若非有负权尽量用dijkstra，但是跟bellman比起来要更优一些

#include<cstdio>
#include<iostream>
#include<queue>
#include<vector>
#include<cstring>
using namespace std;
int n,m,dis[100005],cnt[100005];
bool vis[100005];
struct ren{
	int v,w;
	ren(){};
	ren(int V,int W)
	{
		v=V;
		w=W;
	}
};
queue<int> q;
vector<ren> G[100005];
void add(int x,int y,int z)//加边操作
{
	G[x].push_back(ren(y,z));
}
bool SPFA(int S, int T) {
	memset(dis, 0x3f, sizeof dis);
	q.push(S);
	dis[S] = 0, vis[S] = 0, cnt[S] = 1;
	while (!q.empty()) {
	int u=q.front(); q.pop();
	vis[u]=0;
	for (int i = 0, v, w; i < G[u].size(); i++) {
	v=G[u][i].v,w=G[u][i].w;
	if (dis[v] > dis[u] + w)//松弛
	{
	dis[v] = dis[u] + w;
	if (!vis[v]) 
	{
		vis[v] = 1, cnt[v]++, q.push(v);
	}
	if(cnt[v] > n) //如果入队次数大于n
	{
	return false;	
	}
	}
  }
}
return true;
}
int main()
{
	scanf("%d%d",&n,&m);
	for(int i=1;i<=m;i++)
	{
		int x,y,w;
		scanf("%d%d%d",&x,&y,&w);
		add(x,y,w);//无向图
		add(y,x,w);
	}
	SPFA(1,n);
	if(!SPFA)
	{
		printf("No Solution\n");
	}
	else{
		printf("%d\n",dis[n]);
	}
	return 0;
}
最短路基础与习题
weixin_43870697的博客
07-23 1322
目录 前言 Floyd算法 Dijkstra算法 详解 模板 Spfa算法 详解 模板 例题 A.POJ-2387 Til the Cows Come Home B.POJ-2253 Frogger C.POJ-1797 Heavy Transportation D：POJ-3268 Silver Cow Party E:POJ-1860 Currency Exc...
最短路Dijkstra求最短路(讲解 + 模板 + 例题)
ros275229的博客
05-28 1185
Dijkstra是基于贪心思想的单源最短路算法;变量定义 :核心思路也就是 : 对u操作的时候 ， 有出边u->v(设边权为w),那么就可以尝试更新d[v] = min(d[v] , d[u]+w);图解示例 :注 : 对负边权可能会出错;
最短路——部分例题
CodeSniperYang的博客
08-02 545
记录一下最短路的一些经典例题，当做是模板来用吧。 例题：Title：Agri-Net #include <iostream> #include <queue> #include <cstring> #include <cstdio> #include<stdio.h> #include<string.h> #define sh...
最短路例题
JKdd123456的博客
03-07 501
最短路请戳 ONE： 题目来源 最短路 Problem Description 在每年的校赛里，所有进入决赛的同学都会获得一件很漂亮的t-shirt。但是每当我们的工作人员把上百件的衣服从商店运回到赛场的时候，却是非常累的！所以现在他们想要寻找最短的从商店到赛场的路线，你可以帮助他们吗？ Input 输入包括多组数据。每组数据第一行是...
最短路 Dijkstra Floyd Bellman-Ford SPFA模板及例题 （一次性搞定最短路类型的问题）...
weixin_33812433的博客
08-07 209
从城市A到城市B，有时候可以直达也可以途径其他城市到达，怎样选择最短的路径到达就是最短路问题。 分为单源最短路（所有点到某一特定点的最短路径）和多源最短路（任意两点间的最短路径）。根据边的正负也可以分为带负权边和不带负权边的最短路。 Dijkstra:用于解决不含负权边的单源最短路。基本思想：记S为已经找到到源点的最短路的点的集合，dis【i】表示顶点i到源...
【模板】最短路问题
weixin_30911451的博客
07-04 145
Floyd算法：【佛楼医德】 // luogu-judger-enable-o2 #include<cstdio> #include<iostream> #include<cstring> #include<cstdlib> #include<algorithm> #include<cmath> using...
【Floyd算法】全源最短路算法 洛谷P3647模板例题讲解
wayua的博客
08-01 1179
Floyd算法讲解，洛谷P3647模板含代码详解 全源最短路 图论
图论之最短路问题（acwing模板篇）
lihua777的博客
02-14 975
acwing(6)
C语言---算法模板总结
Z2Min_
05-19 423
一、高精度 1.大数阶乘 2.大数加法、减法 3.大数乘大数 4.大数乘小数（高精度乘单精度） 5.大数除大数 6.大数除小数 7.快速幂运算 8.高精度开根 二、最短路 1.最短路1 2.最短路2 3.例题-昂贵的聘礼 三、最小生成树 1.最小生成树1 2.最小生成树2 3.次小生成树 四、二分查找 五、素数打表 六、点和线段 七、多边形的面积计算 八、...
最短路习题
qq_17080419的博客
09-14 633
最短路习题L2-001 紧急救援 （Dijkstra 求最短路路径数）一个人的旅行 HDU - 2066 （最短路枚举起点）find the mincost route HDU - 1599（Floyd 无向图找最小环）Wormholes POJ - 3259（SPFA 判负环） L2-001 紧急救援 （Dijkstra 求最短路路径数） 链接 题意：给定一个连通图，给定起点和终点，给定边权和点权。求最短路径的数量，同时满足点权和最大、点权和最大的最短路方案。输出路径数、最大点权和、方案。 思路： 首先
数学建模 最短路问题
07-04
是一个关于数学建模的ppt 若大家需要有关方面的东西 可以作为参考
【图论】最短路总结+例题
weixin_43819578的博客
08-30 3256
板子 迪杰斯特拉普通板子 void dli(){ memset(d,0x3f,sizeof(d));//memset可能会错，最好用循环赋值 memset(v,0,sizeof(v)); d[1]=0;//起点的距离是0 for(int i=1;i<n;i++){ int x=0; for(int j=1;j<=n;j++){ if(!v[j]&&...
道路与航线——图论综合性最短路问题，综合性太强把他单独拎出来了
ZZU_LGY
10-23 273
道路与航线–dfs+topsort+dijkstra+建图方式 算法流程 1.先输入所有双向道路，然后DFS出所有连通块，计算两个数组:id[]存储每个点属于哪个连通块;vector<int> block[]存储每个连通块里有哪些点: 2.输入所有航线，同时统计出每个连通块的入度。 3.按照拓扑序依次处理每个连通块，先将所有入度为0的连通块的编号加入队列 中。 4.每次从队头取出一个连通块的编号bid 5.将该block[bid]中的所有点加入堆中，然后对堆中所有点跑dijkstra算法。 6.
最短路问题模板题POJ2387
codechairmanyuan的博客
08-01 673
   对于最短路问题，经常用的两种算法必然是dijkstra算法和SPFA算法，SPFA算法虽然可以解决负权值问题和不需要考虑重边，但是其存在时间不稳定性，所以在单纯的无负权值问题解决方面是不如dijkstra算法的。 下面用POJ2378来介绍两种算法的模板，一般题型可以直接套用。   Bessie is out in the field and wants to get back to t...
最短路的三种算法及例题
TGA麻辣香锅的博客
01-28 1662
跟着宇巨学习图论的一天 （最短路） 记录一下学习笔记和宇巨的代码 1.弗洛伊德算法 3层for循环 时间复杂度n^3 数据量小 感觉跟区间dp的涂色问题好像，但dp我也不会。。 for(int k=1 ;k<=n ;k++)//k是分隔点 作为中间点更新最短路线 for(int i=1 ;i<=n ;i++) for(int j=1 ;j<=n ;j++) a[i][j] = min(a[i][j],a[i][k]+a[k][j]); 2.迪杰斯特拉算法 具体思路：Dijkstra是基
最短路问题（——模板习题与总结）
aisebu7819的博客
07-25 505
　　摘要：本文主要讲解在竞赛中如何求解图中存在环的最短路问题。其中涉及的算法有Floyd算法，Dijkstra算法，使用邻接表和优先队列优化的Dijkstra算法，Bellman-Ford算法，简要总结各算法的基本思想和实现以及使用注意事项。 　　最短路问题主要分为单源最短路问题和多源最短路问题。给出顶点数和边数，以及边的权值，让我们计算从某个顶点到某个顶点的最短路径，单源最短路就是求...
最短路算法模板4种算法
weixin_52879528的博客
07-28 234
最短路算法模板 以下模板全部依据 此模板题 给出，一定要理解模板，具体题目请具体分析，不要死搬硬套 另外，图论（最短路问题只是图论的一小部分）中一般有如下约定： nn 表示顶点数，mm 表示边数 V/v(vertex)V/v(vertex) 表示顶点，E/e(edge)E/e(edge) 表示边 uu 表示起点（也叫源点），vv 表示终点（也叫汇点），ww 表示边权 最短路算法模板目录 Dijkstra算法（包括朴素版和堆优化版） Bellman-Ford算法 SPFA算法（Shortest Path Fa
极其简单的最短路问题
欢迎您的光顾awa
06-01 441
一道bfs 对，你没有看错，不是最短路
最短路（SPFA算法）讲解+例题
WQN20172674的博客
08-29 1873
SPFA 算法介绍 SPFA 算法是 Bellman-Ford算法的队列优化算法的别称，通常用于求含负权边的单源最短路径，以及判负权环。SPFA 最坏情况下复杂度和朴素 Bellman-Ford 相同，为 O(VE)。 算法的思路： （转自https://blog.csdn.net/qq_35644234/article/details/61614581）     我们用数组dis记录每个...
codeforces各类题型总结
最新发布
04-21
我需要确保回答结构清晰，分点列出各个题型类别，每个类别下包括题型特点、解题技巧、例题及解析。同时，按照用户之前的要求，使用中文回答，行内数学公式用$...$，独立公式用$$...$$，并正确使用LaTeX语法。此外，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值