经典算法之图的最短路径(二)：Bellman_Ford算法

Bellman_Ford算法也是一个求图的最短路径的非常经典的算法，它适用于求单源最短路径，相比于同样用于单源最短路径的Dijkstra算法，它的适用范围更广，它可以用于有向图和无向图，并且权值可以为负，如果存在负权回路，可输出提示。

算法的流程就是：每次遍历图中所有边进行松弛（所谓的松弛是这样的——比如说存在一条边e(u,v)，权值为w(u,v)，如果d(v)>d(u)+w(u,v)，则让d(v)=d(u)+w(u,v)），共遍历松弛V-1次（V是点的个数），此时如果不存在负权回路的话，d[i]就是源点到点i 的最短路径，因此再进行一次遍历，查看是否存在d(v)>d(u)+w(u,v)，若存在，说明有负权值回路。下面上代码：（同样是偷懒没有正向打印路径）

package classic;

import java.util.Scanner;

public class Bellman_Ford {

	static int start = 0, V = 0, E = 0;
	static int[][] G = null;
	static int[] d = null, pre = null;
	
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		System.out.println("输入点和边的数目:");
		V = sc.nextInt();//总共有多少个点
		E = sc.nextInt();//总共有多少个边
		
		G = new int[V][V];//用来存放图的信息
		d = new int[V];//用来存放从起点到每个点的最短路径长度
		pre = new int[V];//用来存放每个点在其最短路径上的前一个结点
		
		for(int x=0; x<V; x++){
			for(int y=0; y<V; y++){
				G[x][y] = Integer.MIN_VALUE;
			}
		}
		System.out.println("依次输入每条边的起点、终点和权值:(点的编号从0开始)");
		for(int i=0; i<E; i++){//初始化图
			int u = sc.nextInt();
			int v = sc.nextInt();
			int value = sc.nextInt();
			G[u][v] = value;
			G[v][u] = value;//注意：假如为有向图，则不加这一行！！
		}
		for(int i=0; i<V; i++){//初始化d
			if(i==start)
				d[i] = 0;
			else
				d[i] = Integer.MAX_VALUE/2;
		}
		
		if(!bellman_ford())
			System.out.println("图中存在负权值环");
		else{//打印
			for(int i=0; i<V; i++){
				System.out.println("起点"+start+"到点"+i+"的最短路径长度为:"+d[i]);
				System.out.println("最短路径为:");
				int curv = i;
				System.out.print(i+"<-");
				while(true){
					curv = pre[curv];
					if(curv == start)
						break;
					System.out.print(curv+"<-");
				}
				System.out.println(start);
			}
		}
		sc.close();
	}
	
	static boolean bellman_ford(){
		for(int i=1; i<V; i++){//对每条边都松弛V-1次
			for(int x=0; x<V; x++){
				for(int y=0; y<V; y++){
					if(G[x][y]>Integer.MIN_VALUE){//说明有边
						if(d[y]>d[x]+G[x][y]){
							d[y] = d[x]+G[x][y];
							pre[y] = x;
						}
					}
				}
			}
		}
		for(int x=0; x<V; x++){
			for(int y=0; y<V; y++){
				if(G[x][y]>Integer.MIN_VALUE){//说明有边
					if(d[y]>d[x]+G[x][y]){
						return false;
					}
				}
			}
		}
		return true;
	}

}