最短路径算法——Bellman-Ford

HYC0907

于 2024-08-15 16:01:20 发布

阅读量548

点赞数 10

分类专栏：最短路径算法文章标签：算法

本文链接：https://blog.csdn.net/HYC0907/article/details/141200409

版权

最短路径算法专栏收录该内容

1 篇文章 0 订阅

订阅专栏

今天我们来讲一下求单源最短路径的算法—— Bellman-Ford 的模板写法。

原理

Bellman-Ford ，是一种基于松弛操作去求最短路的算法，它可以求出有负权的图的最短路，还可以判断是否存在最短路。~~哇，听起来好智能！~~

我们先来看看 Bellman-Ford 用到的核心思想——松弛。对于边 ( u , v ) ，我们用 dist( u ) 和 w( u , v ) 的和来尝试去更新 dist( v ) 。也就是：

dist ( v ) = min ( dist ( v ) , dist ( u ) + w ( u , v ) )

这样去做的含义是，我们尝试用 S -> u -> v （ S -> u 的路径取最短路）去更新 S -> v 的最短路，如果这样的话更优，我们就替换它。

Bellman-Ford 做的，就是不断尝试对图上的每一条边进行松弛，当一次循环没有成功地进行松弛操作时，算法停止。

每次循环的时间复杂度是 $O(m)$ ， m 是边的条数。

我们可以画图理解一下：

这是初始的图，然后我们把dist初始化一下

接下来，我们对所有边进行松弛

第一次松弛

第二次松弛

第三次松弛

第四次松弛

那么，有人就会问了，“ 啊，那么我们要进行几轮循环呢? ”

答案是 n - 1 轮。为什么呢？因为，一次松弛操作，它会让最短路的长度至少 +1 （ S -> v 变成 S -> u -> v ），而一个有 n 个顶点的图，任意两点的最短路最多包含 n-1 条边。因为是最多包含 n-1 条边，所以松弛有可能会重复。

那，有的同学就又会问了：“ 如果我们的最短路径包含回路呢？这样就不是最多 n-1 条边啦！”

不可能的，正权回路就不用说了，去掉回路肯定还会有更短的最短路径。负权呢？如果最短路径中有负权回路，那我们每多走一次回路，我们的最短路径就会变短。所以，最短路径是不会包含回路的。

所以，这个算法的时间复杂度是 $O(nm)$ ， n 是顶点个数。

代码（无负环）

那么，我们就可以根据上面的推断，写出代码：

#include<bits/stdc++.h>
using namespace std;
#define inf 0x3f3f3f3f
int u[1000010],v[1000010],w[1000010];
int dist[1000010];
int n,m;
void bellman_ford()
{
	memset(dist,inf,sizeof(dist));
	dist[1]=0;
	for(int k=1;k<=n-1;k++)
	{
		for(int i=1;i<=m;i++)
		{
			if(dist[u[i]]+w[i]<dist[v[i]])
			{
				dist[v[i]]=dist[u[i]]+w[i];
			}
		}
	}
	for(int i=1;i<=n;i++)
	{
		cout<<dist[i]<<" ";
	}
}
int main()
{
	cin>>n>>m;
	for(int i=1;i<=m;i++)
	{
		cin>>u[i]>>v[i]>>w[i];
	}
	bellman_ford();
	return 0;
}

这段代码是计算从 1 到所有点的最短路径。

代码（加判断负环）

Bellman-Ford 还可以判断一个图是否存在负环。

我们知道，对于一个有最短路径的图，松弛 n-1 次就足够了，如果 n-1 次操作后，还有可以松弛的边，我们就可以知道，图中必然有负权环。

代码：

#include<bits/stdc++.h>
using namespace std;
#define inf 0x3f3f3f3f
int u[1000010],v[1000010],w[1000010];
int dist[1000010];
int n,m;
void bellman_ford()
{
	memset(dist,inf,sizeof(dist));
	dist[1]=0;
	bool flag=false;
	for(int k=1;k<=n-1;k++)
	{
		for(int i=1;i<=m;i++)
		{
			if(dist[u[i]]+w[i]<dist[v[i]])
			{
				dist[v[i]]=dist[u[i]]+w[i];
			}
		}
	}
	for(int i=1;i<=m;i++)
	{
		if(dist[u[i]]+w[i]<dist[v[i]])
		{
			flag=true;
			break;
		}
	}
	if(flag)
	{
		cout<<"有负环";
	}
	else
	{
		for(int i=1;i<=n;i++)
		{
			cout<<dist[i]<<" ";
		}
	}
}
int main()
{
	cin>>n>>m;
	for(int i=1;i<=m;i++)
	{
		cin>>u[i]>>v[i]>>w[i];
	}
	bellman_ford();
	return 0;
}

代码（小优化）

但是， Bellman-Ford 算法经常会在没有达到 n-1 轮松弛之前，就已经把最短路给算出来了。我们也说过， n-1 是最大值。所以我们可以添一个 bool 变量，来看看在这一轮松弛中 dist 是否发生了变化，如果没有的话，我们可以跳出循环。

代码：

#include<bits/stdc++.h>
using namespace std;
#define inf 0x3f3f3f3f
int u[1000010],v[1000010],w[1000010];
int dist[1000010];
int n,m;
void bellman_ford()
{
	memset(dist,inf,sizeof(dist));
	dist[1]=0;
	bool flag=false;
	for(int k=1;k<=n-1;k++)
	{
		bool check=false;
		for(int i=1;i<=m;i++)
		{
			if(dist[u[i]]+w[i]<dist[v[i]])
			{
				dist[v[i]]=dist[u[i]]+w[i];
				check=true;
			}
		}
		if(!check)
		{
			break;
		}
	}
	for(int i=1;i<=m;i++)
	{
		if(dist[u[i]]+w[i]<dist[v[i]])
		{
			flag=true;
			break;
		}
	}
	if(flag)
	{
		cout<<"有负环";
	}
	else
	{
		for(int i=1;i<=n;i++)
		{
			cout<<dist[i]<<" ";
		}
	}
}
int main()
{
	cin>>n>>m;
	for(int i=1;i<=m;i++)
	{
		cin>>u[i]>>v[i]>>w[i];
	}
	bellman_ford();
	return 0;
}

可能有的人就会问了，“ 啊，这个算法的松弛操作，怎么有点像动态规划中的状态转移方程啊？”

在 1958 年， Richard Bellman （理查德·贝尔曼）发表了这个算法。