Bellman-Ford求解带有负权图的单源最短路径问题

2019年3月17日 302次阅读来源: Bellman - ford算法

本文参考了书目《算法笔记》

对于一个图如果存在零环、正环，利用Bellman-Ford算法不会影响到最短路径的求解；如果一个图出现了负环，则会导致恶性循环，会导致dis[u]出现负无穷，永远也求解不出来，但如果从源点出发，无法到达负环，则最短路径的求解不会收到影响（不在负环上的dis[u]可以求出确切值，在负环上的点v，标记dis[v]为不可达就行了）

下面是代码：

#include"stdafx.h"
#include<cstdio>
#include<vector>
#include<iostream>
#include<algorithm>
using namespace std;
const int maxn = 500;
const int INF = 1e9;
int Vertexnum, Edgenum, Start;//顶点数、边数、起点
struct node {//结点结构体
	int v;
	int weight;
};
vector<node> adj[maxn];//邻接表存储图
int dis[maxn];
bool BellmanFord(int s) {//s为源点
	fill(dis, dis + maxn, INF);
	dis[s] = 0;
	for (int i = 0; i < Vertexnum - 1; i++) {//进行Vertexnum-1次松弛操作，以确保所有的点都松弛到最佳情况
		for (int u = 0; u < Vertexnum; u++) {//每轮操作都遍历所有的边
			for (int j = 0; j < adj[u].size(); j++) {
				int v = adj[u][j].v;
				int weight = adj[u][j].weight;
				if (dis[u] + weight < dis[v]) {
					dis[v] = dis[u] + weight;
				}
			}
		}
	}
	//已经松弛完毕，下面进行验证是否还能被松弛，如果还能被松弛，则说明此图存在负环
	for (int u = 0; u < Vertexnum; u++) {
		for (int j = 0; j < adj[u].size(); j++) {
			int v = adj[u][j].v;
			int weight = adj[u][j].weight;
			if (dis[u] + weight < dis[v]) {//如果还能被松弛
				return false;//则此图存在负环，返回false
			}
		}
	}
	return true;//数组d的所有值已经达到最优
}
int main() {
	cin >> Vertexnum >> Edgenum >> Start;
	int start, end, weight;//起点、终点、边权
	for (int i = 0; i < Edgenum; i++) {
		cin >> start >> end >> weight;
		node N;
		N.v = end;
		N.weight = weight;
		adj[start].push_back(N);
	}
	bool flag = BellmanFord(Start);
	if (flag == false) cout << "此图存在负环";
	else {
		for (int i = 0; i < Vertexnum; i++) {
			cout << dis[i] << " ";
		}
	}
	return 0;
}

分析：Bellman-Ford算法需要遍历所有的边，显然使用邻接表会比较方便，时间复杂度为O(VE)，但如果使用邻接矩阵，会使时间复杂度达到O(V的三次方)。时间复杂度O(VE)难免有些高，下节将对Bellman-Ford算法进行优化（即SPFA算法）

思路：可以把源点s作为一棵树的根结点，把其它结点按照最短路径的结点顺序连接，就会生成一棵最短路径树。在短路径树中，从源点（根结点）s到达其余各顶点的路径就是原图中对应的最短路径，且原图和源点一旦确定，最短路径树也就确定了。由于在初始状态下dis[s]为0，因此在接下来的步骤中dis[s]不会被改变（也就是说最短路径树中的第一层的dis值被确定），接着，通过Bellman-Ford算法的第一轮操作之后，最短路径树中的第二层顶点的dis值也会被确定下来，然后进行第二轮操作，于是第三层顶点的dis值也被确定下来，这样计算直到最后一层顶点dis值确定，由于最短路径树的层数不超过V层，因此Bellman-Ford算法的松弛操作不会超过V-1轮

转：

Dijkstra算法是处理单源最短路径的有效算法，但它局限于边的权值非负的情况，若图中出现权值为负的边，Dijkstra算法就会失效，求出的最短路径就可能是错的。这时候，就需要使用其他的算法来求解最短路径，Bellman-Ford算法就是其中最常用的一个。该算法由美国数学家理查德•贝尔曼（Richard Bellman, 动态规划的提出者）和小莱斯特•福特（Lester Ford）发明。Bellman-Ford算法的流程如下：

给定图G(V, E)（其中V、E分别为图G的顶点集与边集），源点s，

数组Distant[i]记录从源点s到顶点i的路径长度，初始化数组Distant[n]为, Distant[s]为0；
以下操作循环执行至多n-1次，n为顶点数：
对于每一条边e(u, v)，如果Distant[u] + w(u, v) < Distant[v]，则另Distant[v] = Distant[u]+w(u, v)。w(u, v)为边e(u,v)的权值；
若上述操作没有对Distant进行更新，说明最短路径已经查找完毕，或者部分点不可达，跳出循环。否则执行下次循环；
为了检测图中是否存在负环路，即权值之和小于0的环路。对于每一条边e(u, v)，如果存在Distant[u] + w(u, v) < Distant[v]的边，则图中存在负环路，即是说改图无法求出单源最短路径。否则数组Distant[n]中记录的就是源点s到各顶点的最短路径长度。

可知，Bellman-Ford算法寻找单源最短路径的时间复杂度为O(V*E).

首先介绍一下松弛计算。如下图：