Bellman-Ford与SPFA

Bellman-Ford

Bellman-Ford算法，是单源最短路算法的一种。

与 Dijkstra算法最大的不同是：Dijkstra算法无法判断含负权边的图的最短路，而Bellman-Ford算法可以处理 存在负权边 的最短路径。

由于Bellman-Ford算法简单地对所有边进行松弛操作，共|V|-1次。所以这个算法的时间效率较低，也正是它的不足之处。

Bellman-Ford的时间复杂度： O(V*E) (V,E分别是点数与边数)

图解样例（来源《算法导论》）：

伪代码：

INIT(G,s);
for i=1 to |G.V|-1for each edge(u,v)∈G.ERELAX(u,v,w)
for each edge(u,v)∈G.Eif v.d>u.d+w(u,v)return FLASEreturn TRUE

代码如下（邻接矩阵）：

#include <bits/stdc++.h>
#define INF 0x3f3f3f3f
#define MAXN 1010
int n,m,ori;
//点，边，起点
struct Edge{ int from,to,cost; }edge[MAXN];
//邻接矩阵
int dis[MAXN];
bool Bellman_Ford()
{  for(int i=1;i<=n;++i) dis[i]=(i==ori ? 0 : INF);  //初始化for(int i=1;i<=n-1;++i)      //n-1for(int j=1;j<=m;++j){int u=edge[j].from,v=edge[j].to;if(dis[v]>dis[u]+edge[j].cost)dis[v]=dis[u]+edge[j].cost;}bool flag=1; //判断是否含有负环//原理：负权环可以无限制的降低总权值，所以如果发现第 n次操作仍可降低总权值，就一定存在负权环。for(int i=1;i<=m;++i){int u=edge[i].from,v=edge[i].to;if(dis[v]>dis[u] + edge[i].cost){flag = 0;break;}  }return flag;
}
int main()
{std::scanf("%d%d%d",&n,&m,&ori); for(int i=1;i<=m;++i)std::scanf("%d%d%d",&edge[i].from,&edge[i].to,&edge[i].cost);  if(Bellman_Ford()) //先判断是否有负环  //这里也可以再加一句判断是否连通，依题而定std::printf("%d", dis[n]);else  std::printf("have negative circle\n");  return 0;
}

SPFA（Shortest Path Faster Algorithm）:

Dijkstra有队列优化，Bellman-Ford也有。SPFA是Bellman-Ford的队列优化，减少了不必要的冗余计算。

算法流程：用一个队列来进行维护。初始时将源加入队列。每次从队列中取出一个元素，并对所有与他相邻的点进行松弛，若某个相邻的点松弛成功，则将其入队。直到队列为空时算法结束。

代码如下（邻接表）：

#include <bits/stdc++.h>
#define INF 0x3f3f3f3f
#define MAXN 1010
int n,m,ori;//点，边，起点
struct EDGE{int to,val,nxt;}e[MAXN];
//邻接表
int adj[MAXN],dis[MAXN],cnt=0,num[MAXN];//计数器
bool vis[MAXN]={0};
//判断是否在队列
std::queue < int > q;
void addedge(int u,int v,int w) //链式前向星
{e[++cnt].val=w; e[cnt].to=v; e[cnt].nxt=adj[u]; adj[u]=cnt;
}
bool SPFA(int ori)
{for(int i=1;i<=n;++i) dis[i]=(i==ori ? 0 : INF);q.push(ori); vis[ori]=1; ++num[ori];//起点入队列时记得+1 while(!q.empty()){int u=q.front(); q.pop(); vis[u]=0;for(int i=adj[u];i;i=e[i].nxt) {int v=e[i].to;if(dis[v]>dis[u]+e[i].val) {dis[v]=dis[u]+e[i].val;if(!vis[v]){vis[v]=1;q.push(v);++num[v];//记录加入次数 if(num[v]>n)    return 0;//如果这个点加入超过n次，说明存在负环，直接返回 }}}}return 1;
}
int main()
{std::scanf("%d%d%d",&n,&m,&ori); for(int i=1;i<=m;++i){int u,v,w; std::scanf("%d%d%d",&u,&v,&w);addedge(u,v,w); }if(SPFA(ori)); std::printf("%d", dis[n]); return 0;
}

把负环的判断放在外面会更快一点。（但依然不能避免被卡负环）

(所以并没有什么用) 当一个习惯写吧。

bool SPFA()
{for(int i=1;i<=n;++i)dis[i]=INF;q.push(0); dis[0]=0; vis[0]=1; ++num[0];while(!q.empty()){int u=q.front(); q.pop(); vis[u]=0;if(num[u]>=n) return 0;++num[u];//fasterfor(int i=adj[u];i;i=e[i].nxt){int v=e[i].to;if(dis[v]>dis[u]+e[i].val){dis[v]=dis[u]+e[i].val;if(!vis[v]){vis[v]=1; q.push(v);}}}}return 1;
}

代码风格其实和Dijkstra算法很像（代码思想类似BFS）。唯一的区别就是SPFA中需要有计算器来判断是否存在负环。

对于随机数据而言，时间复杂度：O(kE)（k为一个较小系数）

但SPFA可以人为的造数据，卡负环，导致其性能变得非常低。（时间复杂度达到指数级）

所以，如果题目中不存在负权边，用Dijkstra算法最为保险。

SPFA_DFS

SPFA_DFS，用DFS来优化SPFA。就不怕卡负环啦

算法思路：当DFS的过程中第二次搜到某一节点。

就说明这个图中存在一个环。

优缺点：代码简单效率高；但因为递归，空间会大。

代码如下：

void SPFA(int u)
{if(flag) return;vis[u]=1;for(int i=adj[u];i;i=e[i].nxt){int v=e[i].to;if(dis[v]>dis[u]+e[i].val){dis[v]=dis[u]+e[i].val;if(vis[v]){flag=1;break;}else SPFA(v);}}vis[u]=0;
}

做题感悟：

可以运用在最长路中。（将一开始所有边的权值都改为负数，这样就所求出来的就是最长路）
SPFA,Bellman-Ford都可以用来判断图中是否存在负环，属于判断负环的模板。
可以用来实现 差分约束算法