单源最短路径：bellman-ford算法和SPFA算法

前面讲了单源最短路径的Dijkstra算法和任意两点间最短路径的Floyd算法，今天我们来看一下求单源最短路径的另外两种常用的算法：bellman-ford算法和SPFA算法。至于为什么要把这两个放在一起呢，比较SPFA算法是对bellman-ford算法的改进和优化。

我们先来看一下bellman-ford算法：其实bellman-ford算法和Dijkstra算法是有相似之处的，之所以提出bellman-ford算法，是为了解决带有负权值的最短路径问题。bellman-ford算法的效率很低，他是通过对各边不断的进行松弛，从而达到更新源点到各点的最短距离的；对于一个有n个顶点的图来说，bellman-ford算法的松弛操作需要进行n-1遍，每次松弛都会伴随着最短距离的更新，如果n-1遍松弛之后还能更新最短距离，那么就说明图中存在负权值回路了（拿一个三角形的负权值回路，画一下就能明白了）。

bellman-ford算法的算法流程如下：

（1）初始化：将距离数组dis初始化为源点到该点的权值（也可以初始化为+∞），然后更新到源点dis为0；

（2）松弛更新操作：进行n-1遍松弛（n为图中顶点的个数），每次松弛都更新所有的边；

（3）判负环：若松弛操作之后某条边仍然可以更新，那么就说明图中存在负权值回路。

实现代码如下：

#include <iostream>
#include <cstdio>
#include <cstring>
using namespace std;
#define INF 999999999
#define MAX 1000
typedef struct node
{
int u,v,w;
}EDGE;
EDGE edge[MAX];
int dis[MAX],pre[MAX];
int n,m_edge;
void add(int u,int v,int w)
{
m_edge++;
edge[m_edge].u=u;
edge[m_edge].v=v;
edge[m_edge].w=w;
}
bool bellman_ford()
{
for(int i=0;i<=n;i++)
dis[i]=INF;
dis[1]=0;
for(int i=0;i<n;i++)
for(int j=1;j<=m_edge;j++)
if(dis[edge[j].v]>dis[edge[j].u]+edge[j].w)
{
dis[edge[j].v]=dis[edge[j].u]+edge[j].w;
pre[edge[j].v]=edge[j].u;
}
bool flag=true;
for(int i=1;i<=m_edge;i++)
if(dis[edge[i].v]>dis[edge[i].u]+edge[i].w)
{
flag=false;
break;
}
return flag;
}
void print_path(int x)
{
while(x!=pre[x])
{
printf("%d-->",x);
x=pre[x];
}
if(x==pre[x])
printf("%d\n",x);
}
int main()
{
int m;
int u,v,w;
m_edge=0;
for(int i=0;i<m;i++)
{
scanf("%d%d%d",&u,&v,&w);
add(u,v,w);//有向图
add(v,u,w);
}
if(bellman_ford())
for(int i=0;i<n;i++)//源点到每个点的最短路径
{
printf("%d\n",dis[i]);
printf("path:");
print_path(i);
}
else printf("存在负权值回路\n");
return 0;
}

接下来我们看一下SPFA算法：

SPFA（Shortest Path Faster Algorithm）是对bellman-ford算法的一种队列优化。算法大致流程就是用一个队列来进行维护图中的n个顶点，初始时讲源点加入队列，每次从队列中取一个元素，并对所有与它相邻的点进行松弛更新，更新完后该点出队，在这个过程中，若某个点更新了，就把这个点入队，直到队列中的元素为0，算法结束。

SPFA算法可以在O（KE）的时间复杂度内求出源点到其他点的最短路径，可以处理负权边，某些情况甚至比Dijkstra算法更有效，但稳定性不如Dijkstra算法。

算法流程如下：

（1）初始化：将源点到每一点的距离dis初始化为+∞，将标记数组vis初始化为false，表示所有点都没有入队；更新源点的dis为0，同时将源点入队，改变vis为true；

（2）松弛更新操作：每次取队头元素tmp（更新vis[ tmp ]为false），枚举从tmp出发的每一条边，如果某条边能够松弛且该点没有在队列中，那么将该点入队；直至队列为空；

（3）判负环：如果图中某点入队的次数超过n，那么图中存在负环（SPFA无法处理带负环的问题）。

实现代码如下，和BFS有点相似：

邻接矩阵实现代码：

int  n,m;//n代表顶点数，m表示边数
int w[MAX][MAX];//邻接矩阵表示图
int dis[MAX];//源点到各点的最短路
bool vis[MAX];//标记数组
void SPFA()
{
for(int i=0;i<n;i++)
{
dis[i]=INF;
vis[i]=false;
}
queue<int> que;
que.push(start);
dis[start]=0;
vis[start]=true;
while(!que.empty())
{
int tmp=que.front();
que.pop();
vis[tmp]=false;
for(int i=0;i<n;i++)
if(dis[i]>dis[tmp]+w[tmp][i])
{
dis[i]=dis[tmp]+w[tmp][i];
if(!vis[i])
{
que.push(i);
vis[i]=true;
}
}
}
}

对于图中边数和顶点数比较大的情况，邻接矩阵显然不能满足我们的要求，这里用vector容器来装某一顶点相邻的边的信息，实现代码如下：

#include <cstdio>
#include <iostream>
#include <queue>
#include <vector>
using namespace std;
#define INF 0x7fffffff
#define MAX 100005
struct edge
{
int to,w;
};
int dis[MAX];
bool vis[MAX];
int n,m,start,e;
vector <edge> vec[MAX];
void SPFA()
{
for(int i=1;i<=n;i++)
{
dis[i]=INF;
vis[i]=false;
}
dis[start]=0;
queue<int> que;
que.push(start);
vis[start]=true;
while(!que.empty())
{
int tmp=que.front();
que.pop();
vis[tmp]=false;
for(int i=0;i<vec[tmp].size();i++)
{
edge cnt=vec[tmp][i];
if(dis[ cnt.to ]>dis[tmp]+cnt.w)
{
dis[ cnt.to ]=dis[tmp]+cnt.w;
if(!vis[ cnt.to ])
{
que.push(cnt.to);
vis[ cnt.to ]=true;
}
}
}
}
}
int main()
{
cin>>n>>m>>start>>e;
for(int i=0;i<=n;i++)
vec[i].clear();
for(int i=1;i<=m;i++)
{
edge cnt1,cnt2;
int u,v,w;
scanf("%d%d%d",&u,&v,&w);
cnt1.to=u;cnt1.w=w;
cnt2.to=v;cnt2.w=w;
vec[u].push_back(cnt2);
vec[v].push_back(cnt1);
}
SPFA();
cout<<dis[e]<<endl;
return 0;
}