算法简介

贝尔曼-福特算法(Bellman–Ford algorithm )用于计算出起点到各个节点的最短距离，支持存在负权重的情况

它的原理是对图进行最多V-1次松弛操作，得到所有可能的最短路径。其优于迪科斯彻算法的方面是边的权值可以为负数、实现简单，缺点是时间复杂度过高，高达O(VE)。但算法可以进行若干种优化，提高了效率。
Bellman Ford算法每次对所有的边进行松弛，每次松弛都会得到一条最短路径，所以总共需要要做的松弛操作是V - 1次。在完成这么多次松弛后如果还是可以松弛的话，那么就意味着，其中包含负环。
相比狄克斯特拉算法(Dijkstra algorithm),其最大优点便是Bellman–Ford支持存在负权重的情况，并且代码实现相对简单。缺点便是时间复杂度较高，达到O(V*E)，V代表顶点数，E代表边数。

可用于解决以下问题：

从A出发是否存在到达各个节点的路径(有计算出值当然就可以到达)；
从A出发到达各个节点最短路径(时间最少、或者路径最少等)
图中是否存在负环路（权重之和为负数）

其思路为：

初始化时将起点s到各个顶点v的距离dist(s->v)赋值为∞，dist(s->s)赋值为0
后续进行最多n-1次遍历操作(n为顶点个数,上标的v输入法打不出来...),对所有的边进行松弛操作,假设:

所谓的松弛，以边ab为例，若dist(a)代表起点s到达a点所需要花费的总数， dist(b)代表起点s到达b点所需要花费的总数,weight(ab)代表边ab的权重，若存在:

(dist(a) +weight(ab)) < dist(b)

则说明存在到b的更短的路径,s->...->a->b,更新b点的总花费为(dist(a) +weight(ab))，父节点为a
遍历都结束后，若再进行一次遍历，还能得到s到某些节点更短的路径的话，则说明存在负环路

思路上与狄克斯特拉算法(Dijkstra algorithm)最大的不同是每次都是从源点s重新出发进行"松弛"更新操作，而Dijkstra则是从源点出发向外扩逐个处理相邻的节点，不会去重复处理节点，这边也可以看出Dijkstra效率相对更高点。

案例

案例一

先举个网上常见的例子介绍其实现的思路:

如下图按Bellman–Ford算法思路获取起点A到终点的最短路径

由上介绍可知，由于该图顶点总数n=5个顶点，所以需要进行5-1 = 4 次的遍历更新操作，每次操作若能发现更短的路径则更新对应节点的值

1.首先建立边对象信息,需要按从源点A出发，由近到远的顺序，不然没从源点开始的话dist(s)==∞无穷大会增加后续计算的麻烦:

AB:-1
AC:4
BC:3
BE:2
BD:2
ED:-3
DC:5
DB:1

1.首先列出起点A到各个节点耗费的时间:

父节点	节点	初始化
A	A	0
..	B	∞
..	C	∞
..	D	∞
..	E	∞

2.进行第一次对所有边进行的松弛操作:

2.1统计经过1条边所能到达的节点的值AB,AC：

AB:-1
AC:4

父节点	节点	耗费
A	A	0
A	B	-1
A	C	4
..	D	∞
..	E	∞

2.2统计经过2条边所能到达的节点的值BC,BD,BE：

BC:3
BE:2
BD:2

父节点	节点	耗费
A	A	0
A	B	-1
B	C	2
B	D	1
B	E	1

以节点C为例,因为满足: dist(B) + weight(BC) > dist(C),即 -1 + 3 >4，所以C更新为2

2.3统计经过3条边所能到达的节点的值ED,DC：

ED:-3
DC:5
DB:1

父节点	节点	耗费
A	A	0
A	B	-1
B	C	2
E	D	-2
B	E	1

3.尝试再进行第2次遍历，对所有边进行松弛操作，发现没有节点需要进行更新，此时便可以提前结束遍历，优化效率

父节点	节点	耗费
A	A	0
A	B	-1
B	C	2
E	D	-2
B	E	1

4.由上表可知，此时便求出了源点A到各个节点的最短路径与线路

案例二

如下图，求出A到各节点的最短路径

1.该图共有节点7个，最多需要进行7-1=6次的对所有边的松弛操作

2.首先创建边对象:

AB:6
AC:5
AD:5
CB:-2
DC:-2
BE:-1
CE:1
DF:-1
EG:3
FG:3

3.进行第一次遍历松弛操作，可以得到:

父节点	节点	耗费
A	A	0
C	B	3
D	C	3
A	D	5
B	E	2
D	F	4
E	G	5

4.进行第二次遍历松弛操作，得到:

父节点	节点	耗费
A	A	0
C	B	1
D	C	3
A	D	5
B	E	0
D	F	4
E	G	3

5.进行第三次遍历松弛操作，结果并没有再次更新:

父节点	节点	耗费
A	A	0
C	B	1
D	C	3
A	D	5
B	E	0
D	F	4
E	G	3

6.此时上表边上A到各个节点的最短路径，可以通过倒序的方式得出路线

8.这边假设同级边对象(指的是从A出发，经过相同的边数可以到达的，比如DC,CB,BE,DF,CE经过2条边就可以到达)排序位置进行调整,并不会影响结果的正确性，但是会影响所需要的遍历的次数(不同级别):

比如上述,AB:6 ,AC:5,AD:5,CB:-2,DC:-2,BE:-1,CE:1,DF:-1,EG:3,FG:3 代码需要遍历3次才可以确认结果(最后一次用于确认结果不再更新)；

AB:6，AC:5，AD:5，DC:-2，CB:-2，BE:-1，CE:1，DF:-1，EG:3，FG:3 代码需要遍历2次就可以确认结果；

AB:6，AC:5，AD:5，BE:-1，CE:1，DF:-1，DC:-2，CB:-2，EG:3，FG:3 代码需要遍历4次就可以确认结果；

有时候图的关系是用户输入的，对于顺序并不好强制一定是最佳的

局限性

案例三,存在负环路的情况

对案例一的图进行修改B->D为-2.使得B<->D这形成了负环路，所谓的负环路指的是环路权重之和为负数，比如上图 1 + (-2) = -1 < 0即为负环路。
因为负环路可以无限执行循环步骤，只要你想，可以在 B->D->B->D...这边无限循环，所以B、D的取值可以无限小，然后当B、D取值无限小后再从B、D节点出发到达其他各个节点，都会导致其它节点的取值同样接近无限小，所以对于负环路的情况，Bellman–Ford只能判断出图存在负环路，而没有求出各个节点最短路径的意义
Bellman–Ford求出的各个节点的最短路径后，可以再进行一次遍历，就可以判断出是否存在负环路。

例如,同案例一，对该图执行4次遍历后得到结果:

父节点	节点	耗费	执行线路
A	A	0
A	B	-2	A->B->D->B
B	C	1	A->B->D->B->C
E	D	-4	A->B->D-B->D
B	E	0	A->B->D->B->E

此时结束后，所得到的结果并非是正确的最短路径，比如再进行一次遍历，更新从源点A出发，经过5条边所能到达的节点的值

父节点	节点	耗费	执行线路
A	A	0
A	B	-3	A->B->D->B->D->B
B	C	1	A->B->D->B->C
E	D	-4	A->B->D-B->D
B	E	0	A->B->D->B->E

发现此时存在可以更新的节点B，则证明图中存在了负环路。

当没限制次数时，则无法得出各个节点的最短路径，若人为限制了遍历次数，则可以找出源点到各个节点的最短路径

小结

1.广度优先算法BFS主要适用于无权重向图重搜索出源点到终点的步骤最少的路径，当方向图存在权重时，不再适用

2.狄克斯特拉算法Dijkstra主要用于有权重的方向图中搜索出最短路径，但不适合于有负权重的情况.对于环图，个人感觉和BFS一样，标志好已处理的节点避免进入死循环，可以支持

3.贝尔曼-福特算法Bellman–Ford主要用于存在负权重的方向图中(没有负权重也可以用，但是效率比Dijkstra低很多)，搜索出源点到各个节点的最短路径

4.Bellman–Ford可以判断出图是否存在负环路，但存在负环路的情况下不支持计算出各个节点的最短路径。只需要在结束(节点数目-1)次遍历后，再执行一次遍历，若还可以更新数据则说明存在负环路

5.当人为限制了遍历次数后，对于负环路也可以计算出，但似乎没啥实际意义

java实现

/**
 * 贝尔曼-福特算法
 * @author Administrator
 *
 */
public class BellmanFord {
	public static void main(String[] args){
		
		//创建图
		Edge ab = new Edge("A", "B", -1);
		Edge ac = new Edge("A", "C", 4);
		Edge bc = new Edge("B", "C", 3);
		Edge be = new Edge("B", "E", 2);
		Edge ed = new Edge("E", "D", -3);
		Edge dc = new Edge("D", "C", 5);
		Edge bd = new Edge("B", "D", 2);
		Edge db = new Edge("D", "B", 1);
		
		//需要按图中的步骤步数顺序建立数组，否则就是另外一幅图了，
		//从起点A出发，步骤少的排前面
		Edge[] edges = new Edge[] {ab,ac,bc,be,bd,ed,dc,db};
		
		//存放到各个节点所需要消耗的时间
		HashMap<String,Integer> costMap = new HashMap<String,Integer>();
		//到各个节点对应的父节点
		HashMap<String,String> parentMap = new HashMap<String,String>();
		
		
		//初始化各个节点所消费的，当然也可以再遍历的时候判断下是否为Null
		//i=0的时候
		costMap.put("A", 0); //源点
		costMap.put("B", Integer.MAX_VALUE);
		costMap.put("C", Integer.MAX_VALUE);
		costMap.put("D", Integer.MAX_VALUE);
		costMap.put("E", Integer.MAX_VALUE);
		
		//进行节点数n-1次循环
		for(int i =1; i< costMap.size();i++) {
			boolean hasChange = false;
			for(int j =0; j< edges.length;j++) {
				Edge edge = edges[j];
				//该边起点目前总的路径大小
				int startPointCost = costMap.get(edge.getStartPoint()) == null ? 0:costMap.get(edge.getStartPoint());
				//该边终点目前总的路径大小
				int endPointCost = costMap.get(edge.getEndPoint()) == null ? Integer.MAX_VALUE : costMap.get(edge.getEndPoint());
				//如果该边终点目前的路径大小 > 该边起点的路径大小 + 该边权重 ，说明有更短的路径了
				if(endPointCost > (startPointCost + edge.getWeight())) {
					costMap.put(edge.getEndPoint(), startPointCost + edge.getWeight());
					parentMap.put(edge.getEndPoint(), edge.getStartPoint());
					hasChange = true;
				}
			}
			if (!hasChange) {
				//经常还没达到最大遍历次数便已经求出解了，此时可以优化为提前退出循环
				break;
			}
		}
		
		//在进行一次判断是否存在负环路
		boolean hasRing = false;
		for(int j =0; j< edges.length;j++) {
			Edge edge = edges[j];
			int startPointCost = costMap.get(edge.getStartPoint()) == null ? 0:costMap.get(edge.getStartPoint());
			int endPointCost = costMap.get(edge.getEndPoint()) == null ? Integer.MAX_VALUE : costMap.get(edge.getEndPoint());
			if(endPointCost > (startPointCost + edge.getWeight())) {
				System.out.print("\n图中存在负环路，无法求解\n");
				hasRing = true;
				break;
			}
		}
		
		if(!hasRing) {
			//打印出到各个节点的最短路径
			for(String key : costMap.keySet()) {
				System.out.print("\n到目标节点"+key+"最低耗费:"+costMap.get(key));
				if(parentMap.containsKey(key)) {
					List<String> pathList = new ArrayList<String>();
					String parentKey = parentMap.get(key);
					while (parentKey!=null) {
						pathList.add(0, parentKey);
						parentKey = parentMap.get(parentKey);
					}
					pathList.add(key);
					String path="";
					for(String k:pathList) {
						path = path.equals("") ? path : path + " --> ";
						path = path +  k ;
					}
					System.out.print("，路线为"+path);
				} 
			}
		}

		
	}
	

	
	/**
	 * 	代表"一条边"的信息对象
	 * 
	 * @author Administrator
	 *
	 */
	static class Edge{
		//起点id
		private String startPoint;
		//结束点id
		private String endPoint;
		//该边的权重
		private int weight;
		public Edge(String startPoint,String endPoint,int weight) {
			this.startPoint = startPoint;
			this.endPoint = endPoint;
			this.weight = weight;
		}
		public String getStartPoint() {
			return startPoint;
		}
		
		public String getEndPoint() {
			return endPoint;
		}
		
		public int getWeight() {
			return weight;
		}
	}
}

执行完main方法打印信息如下:
到目标节点B最低耗费:-1，路线为A --> B
到目标节点C最低耗费:2，路线为A --> B --> C
到目标节点D最低耗费:-2，路线为A --> B --> E --> D
到目标节点E最低耗费:1，路线为A --> B --> E

微信公众号