Bellman-ford算法详解

什么是Bellman-ford算法

贝尔曼-福特算法(Bellman-Ford)是由理查德·贝尔曼(Richard Bellman)和莱斯特·福特创立的,求解单源最短路径问题的一种算法。其优于Dijkstra的方面是边的权值可以为负数、实现简单,缺点是时间复杂度过高。但它也有特别的用处,一般用于实现通过m次迭代求出从起点到终点不超过m条边构成的最短路径。

Dijkstra算法不能解决带有负权边的问题,而Bellman-ford算法可以解决带有负权边的问题,是求解带负权边的单源最短路问题的经典算法。时间复杂度是O(nm),核心思想是”松弛操作”。解决带负权边的单源最短路问题还有一个常用的算法是SPFA算法,SPFA算法的时间复杂度一般是O(m),最坏是O(nm)。

总结一下就是Dijkstra算法可以解决不带负权边的问题,而对于带有负权边的问题,又有Bellman-ford算法和SPFA解决。

基本思路

首先n次迭代,每一次循环所有边。我们这里用a,b,w表示存在一条从a走到b的边,权重是w。这里存边方式有很多种,可以用邻接表,结构体等。遍历所有边的时候更新一下其他点的距离,和Dijkstra算法类似,用当前这个点更新和它相连的点距离起点的距离。我们这里用dist数组表示每个点到起点的距离,那么更新操作就是dist[b]=min(dist[b],dist[a]+w),这样就可以更新和a相连的b点距离起点的距离,这个更新的过程就是”松弛操作”。忘了说的一点就是在循环所有边的时候,每一次循环要先把dist数组备份一下,防止串联,这个后面会说循环n次之后对所有的边一定满足dist[b]<=dist[a]+w,这个叫”三角不等式”。

这个就是Bellman-ford算法的基本思路。

但是注意如果图中有负权回路的话,最短路就不一定存在了

举个栗子

Bellman-ford算法详解_第1张图片

我们看这个图,红色的数字表示边的权重,我们想求一下1号点到5号点的最短路径,我们从1走到2,2,3,4号点围成了一个圈,圈的总权重是5+-4+-2=-1,那么转一圈长度就会减一,因此我们可以转无穷多圈,转无穷多圈总长度就会变成负无穷,出圈的话还是负无穷。所以说图中存在负权回路的话,从1号点到n号点的距离就会变成负无穷,就不存在了。

所以能求出来最短路的话,图中是没有负权回路的。

而Bellman-ford算法是可以判断图中存不存在负权回路。首先上面的迭代次数是有实际意义的,比如我们迭代了k次,那么我们求的最短距离就是从1号点经过不超过k条边走到n号点的最短距离。所以在第n次迭代的时候又更新了某些边的话,就说明路径中一定存在环,并且是负权回路。因为第n次迭代在不存在负权回路的情况下是遍历到第n号点了,后面是没有点了,如果还能更新,说明路径中存在回路,而且是负权回路。

但是一般找负环是不用Bellman-ford算法,一般是用SPFA算法,这里我们只要知道Bellman-ford算法可以找负权回路即可。

总结

Bellman-ford算法的思路也很简单,直接就是两层循环,内层循环所有边,外层循环就是循环所有边的次数,这个外层循环次数一般是题目控制的。时间复杂度是O(n*m)

案例

给定一个 n 个点 m 条边的有向图,图中可能存在重边和自环, 边权可能为负数

请你求出从 1 号点到 nn 号点的最多经过 kk 条边的最短距离,如果无法从 1 号点走到 n 号点,输出 impossible

注意:图中可能 存在负权回路 。

输入格式

第一行包含三个整数 n,m,k。

接下来 m 行,每行包含三个整数 x,y,z,表示存在一条从点 x到点 y 的有向边,边长为 z。

点的编号为 1∼n。

输出格式

输出一个整数,表示从 1 号点到 n 号点的最多经过 k 条边的最短距离。

如果不存在满足条件的路径,则输出 impossible

数据范围

1≤n,k≤500
1≤m≤10000
1≤x,y≤n
任意边长的绝对值不超过 10000。

输入样例:

3 3 1
1 2 1
2 3 1
1 3 3

输出样例:

3

思路

这里要注意的就是我们用结构体去存边的信息,还有一个就是backup数组,这个数组是给dist数组备份的数组。我们在循环所有边的操作中,在每一次循环之前要先把上一次循环后的dist数组备份一下。防止"串联",什么是串联呢?

举个栗子

我们以样例为例

Bellman-ford算法详解_第2张图片

样例是这样一张图,k是1,也就是要求从1号点出发到3号点最多经过1条边的最短距离,通过图很容易就可以看出,最短距离就是3,也就是1号点直接到3号点的距离。

这里我们已经知道最短距离是3了,如果我们不把上一次循环后的dist备份的话会出现什么后果呢?我们根据Bellman-ford算法的步骤,也就是两层循环,外层循环题目控制的是k,也就是1,内层循环所有的边。也就说只会进行一次迭代。我们看一下内层循环的过程,首先一共有三条边,所以内层循环要循环三次。我们看一下内层循环后的结果。注意:这里是没有备份dist数组的结果

1号点

2号点

3号点

内层循环第一次执行

0

内层循环第二次执行

0

1

内层循环第三次执行

0

1

2

可以发现,如果我们没有备份上一次的dist数组的话,最短距离变成了2。内层循环只迭代了一次,但是在更新的过程中会发生”串联”。比如说先更新了2号点,然后我们用2号点更新了3号点距离起点的距离,这样就发生了”串联”,,3号点不能被2号点更新,这样就不满足题目要求了,因为题目要求最多不经过1条边,上面我们说了,迭代次数是有实际意义的,我们迭代1次,那我们求的最短距离就是最多不经过1条边的最短距离。

怎么保证不发生串联呢?我们保证更新的时候只用上一次循环的结果就行。所以我们先备份一下。备份之后backup数组存的就是上一次循环的结果,我们用上一次循环的结果来更新距离。所以我们这样写dist[b]=min(dist[b],backup[a]+w)来更新距离,而不是dist[b]=min(dist[b],dist[a]+w),这样写就会发生上面说的”串联”现象。

代码实现

#include 
#include 
#include 
using namespace std;
const int N=510,M=1e4+10;
int dist[N],backup[N];
int n,m,k;
//这里用结构体存边的信息
struct node
{
    int a,b,c;
}edg[M];
int bellman_ford()
{
    //初始化距离
    memset(dist,0x3f,sizeof dist);
    dist[1]=0;
    for(int i=0;i>n>>m>>k;
    for(int i=0;i>a>>b>>c;
        edg[i]={a,b,c};
    }
    //这里不用0x3f3f3f3f是因为防止n号点被负权边更新
    if(bellman_ford()>0x3f3f3f3f/2)
    cout<<"impossible";
    else
    cout<

你可能感兴趣的:(数据结构与算法,算法,数据结构,图论)