最短路—Bellman-ford算法教程（邻接矩阵+邻接表+前向星）

1 简介

贝尔曼-福特算法（英语：Bellman–Ford algorithm），求解单源最短路径问题的一种算法，由理查德·贝尔曼（Richard Bellman） 和 莱斯特·福特 创立的。有时候这种算法也被称为 Moore-Bellman-Ford 算法，因为 Edward F. Moore 也为这个算法的发展做出了贡献。它的原理是对图进行次松弛操作，得到所有可能的最短路径。其优于迪科斯彻算法的方面是边的权值可以为负数、实现简单，缺点是时间复杂度过高，高达O(VE)。

适用条件如下：

1. 单源最短路径(从源点s到其它所有顶点v);
2. 有向图&无向图(无向图可以看作(u,v),(v,u)同属于边集E的有向图);
3. 边权可正可负(如有负权回路输出错误提示);

---

2 原理

每次松弛操作实际上是对相邻节点的访问，第 n次松弛操作保证了所有深度为n的路径最短。由于图的最短路径最长不会经过超过 |V|-1条边，所以可知Bellman-ford算法所得为最短路径。

与Dijkstra算法不同的是，Dijkstra算法的基本操作“拓展”是在深度上寻路，而“松弛”操作则是在广度上寻路，这就确定了贝尔曼-福特算法可以对负边进行操作而不会影响结果。

因为负权环可以无限制的降低总花费，所以如果发现第 n次操作仍可降低花销，就一定存在负权环。

这是整个算法的核心，松弛操作就是利用松弛函数。
对边集合E中任意边，以w(u,v)表示顶点u出发到顶点v的权值，以d[v]表示当前从起点s到顶点v的路径权值。
若存在边w(u,v)使得：

d[v]>d[u]+w(u,v) 则更新d[v]值： d[v]=d[u]+w(u,v) 所以松弛函数的作用，就是判断是否经过某个顶点，或者说经过某条边，可以缩短起点到终点的路径权值。

---

3 具体实现

实现此算法可以利用多种存储结构，我这里列出了三种：1、邻接矩阵；2、前向星；3、vector模拟邻接表。第一种适用于稠密图，第二种和第三种适用于稀疏图。下面的实现若有问题还请私信我或者评论区留言（个人测试是没有问题的）。

3.1 邻接矩阵实现

#include<iostream>
#include<cstdio>
#include<cstdlib>
#include<algorithm>
#include<cmath>
#include<string>
#include<stack>
#include<queue>
#include<cstring>
#include<map>
#include<iterator>
#include<list>
#include<set>
#include<functional>
#include<memory.h>

using namespace std;

const int maxn=105;//顶点最大数
const int inf=0x3f3f3f3f;
int n,m;//顶点数与边数。
int graph[maxn][maxn];//邻接矩阵存储图
int dis[maxn];//存储所有顶点到源点的距离。
void init(){
	memset(dis,inf,sizeof(dis));
	memset(graph,inf,sizeof(graph));
}
int bellman_ford(int S){
	dis[S]=0;
	for(int i=1;i<=n;i++){
		for(int j=1;j<=n;j++){
			//进行松弛操作
			if(dis[j]>dis[i]+graph[i][j]){
				dis[j]=dis[i]+graph[i][j];
			}
		}
	}
	int flag=0;
	for(int i=1;i<=n;i++){
		for(int j=1;j<=n;j++){
			//进行松弛操作
			if(dis[j]>dis[i]+graph[i][j]){
				flag=1;
			    break;
			}
		}
	}
	return flag;
}
int main(){
	while(cin>>n>>m){
		int u,v,w;
		init();
		for(int i=0;i<m;i++){
			cin>>u>>v>>w;
		    graph[u][v]=graph[v][u]=w;
		}
		int S,E;//起点与终点。
		cin>>S>>E;
		int result=bellman_ford(S);
		if(result)cout<<"此存在负权回路，计算两点之间距离可能没有意义,输出的仅供参考"<<endl;
		cout<<dis[E]<<endl;
	}
	return 0;
}

3.2 前向星实现

#include<iostream>
#include<cstdio>
#include<cstdlib>
#include<algorithm>
#include<cmath>
#include<string>
#include<stack>
#include<queue>
#include<cstring>
#include<map>
#include<iterator>
#include<list>
#include<set>
#include<functional>
#include<memory.h>

using namespace std;

const int maxn=105;//顶点最大数
const int M=1e4;//边最大数
const int inf=0x3f3f3f3f;
int n,m;//顶点数与边数。
int cnt;//递增存储边。
typedef struct Edge{
	int u;//边起点
	int v;//边的终端节点
	int w;//边权值。
	Edge(){};
	Edge(int u,int v,int w):u(u),v(v),w(w){}//构造函数
}Edge;
Edge edge[M];//前向星存储
int dis[maxn];//存储所有顶点到源点的距离。
void init(){
	memset(dis,inf,sizeof(dis));
}
int  bellman_ford(int S){
	dis[S]=0;
	for(int i=1;i<=n;i++){
		for(int j=0;j<cnt;j++){
			//进行松弛操作，不断接近真实最短路径
			if(dis[edge[j].v]>dis[edge[j].u]+edge[j].w){
				dis[edge[j].v]=dis[edge[j].u]+edge[j].w;
			}
		}
	}
	int flag=0;
	for(int j=0;j<cnt;j++){
		//如果还能进行松弛操作，说明存在负权回路。
		if(dis[edge[j].v]>dis[edge[j].u]+edge[j].w){
			flag=1;
		    break;
		}
	}
	return flag;
}
int main(){
	while(cin>>n>>m){
		int u,v,w;
		init();
		cnt=0;
		for(int i=0;i<m;i++){
			cin>>u>>v>>w;
		    edge[cnt].u=u;edge[cnt].v=v;edge[cnt].w=w;  //这里是针对无向图。一定要注意的是，无向图中有负边的话一定存在负权回路，而负权回路是没有意义的。
		    cnt++;
		    edge[cnt].u=v;edge[cnt].v=u;edge[cnt].w=w;
		    cnt++;
		}
		int S,E;//起点与终点。
		cin>>S>>E;
		int result=bellman_ford(S);
		if(result)cout<<"此存在负权回路，计算两点之间距离可能没有意义,输出的仅供参考"<<endl;
		cout<<dis[E]<<endl;
	}
	return 0;
}

3.3 vector模拟邻接表实现

#include<iostream>
#include<cstdio>
#include<cstdlib>
#include<algorithm>
#include<cmath>
#include<string>
#include<stack>
#include<queue>
#include<cstring>
#include<map>
#include<iterator>
#include<list>
#include<set>
#include<functional>
#include<memory.h>

using namespace std;

const int maxn=105;//顶点最大数
const int M=1e4;//边最大数
const int inf=0x3f3f3f3f;
int n,m;//顶点数与边数。
typedef struct Edge{
	int to;//边的终端节点
	int w;//边权值。
	Edge(int to,int w):to(to),w(w){}//构造函数
}Edge;
vector<Edge> graph[maxn];//用vector模拟邻接表
int dis[maxn];//存储所有顶点到源点的距离。
void init(){
	memset(dis,inf,sizeof(dis));
}
int bellman_ford(int S){
	dis[S]=0;
	int t;
	int temp,len;
	for(int i=1;i<=n;i++){
			t=graph[i].size();
		for(int j=0;j<t;j++){
			temp=graph[i][j].to;
			len=graph[i][j].w;
			if(dis[temp]>dis[i]+len)
				dis[temp]=dis[i]+len;
		}
	}
	int flag=0;
	//判断是否存在负环。
	for(int i=1;i<=n;i++){
			t=graph[i].size();
		for(int j=0;j<t;j++){
			temp=graph[i][j].to;
			len=graph[i][j].w;
			if(dis[temp]>dis[i]+len){
				flag=1;
				break;
			}
		}
	}
	return flag;
}
int main(){
	while(cin>>n>>m){
		int u,v,w;
		init();
		for(int i=0;i<m;i++){
			cin>>u>>v>>w;
		    graph[u].push_back(Edge(v,w));//这里针对的是无向图，有向图加边只加一次。
		    graph[v].push_back(Edge(u,w));
		}
		int S,E;//起点与终点。
		cin>>S>>E;
		int result=bellman_ford(S);
		if(result)cout<<"此存在负权回路，计算两点之间距离可能没有意义,输出的仅供参考"<<endl;
		cout<<dis[E]<<endl;
	}
	return 0;
}

个人不推荐使用这种版本Bellman-ford算法，最好使用队列优化的Bellman-ford算法，也就是SPFA算法，但这个算法的思想十分重要，思想即灵魂。