算法導論——全部點對的最短路徑：FloydWarshall算法

package org.loda.graph;

import java.math.BigDecimal;
import java.math.RoundingMode;

import org.loda.util.In;

/**
 * 
 * @ClassName: FloydWarshall
 * @Description: 求一個圖中任意兩點之間的最短路徑
 * 
 *               FloydWarshall算法是經過動態規劃來計算任意兩點之間的最短路徑
 * 
 *               若是普通求最短路徑，能夠對圖進行V次（頂點數）BellmanFord算法。 這樣的話時間複雜度爲EV^2
 *               若是是稀疏圖，則近似於V^3
 *               可是若是是密集圖，則時間複雜度會近似達到V^4，這種狀況須要優化，這裏FloydWarshall經過動態規劃進行優化
 *               ，而且使用鄰接矩陣來表示圖。 
 *               			d(i,j); if m=0 
 *               D(i,j,m)={
 *               			min(D(i,m,m-1)+D(m,j,m-1),D(i,j,m-1)); if m!=0
 * @author minjun
 * @date 2015年6月1日 上午9:39:42
 * 
 */
public class FloydWarshall {

	private double[][] d;

	private int[][] prev;

	private int v;

	private boolean negativeCycle;

	public FloydWarshall(int v) {
		this.v = v;

		d = new double[v][v];

		prev = new int[v][v];

		// 默認設置全部節點都不可達，而本身到本身是可達而且距離爲0.0
		for (int i = 0; i < v; i++) {
			for (int j = 0; j < v; j++) {
				d[i][j] = Double.POSITIVE_INFINITY;
				prev[i][j] = -1;
				if(i==j){
					d[i][j] = 0;
				}
			}
		}
	}

	/**
	 * 
	 * @Title: findShortestPath
	 * @Description: 查詢最短路徑
	 * @param 設定文件
	 * @return void 返回類型
	 * @throws
	 */
	public void findShortestPath() {
		//查找最短路徑
		for (int k = 0; k < v; k++) {
			//將每一個k值考慮成i->j路徑中的一箇中間點
			for (int i = 0; i < v; i++) {
				for (int j = 0; j < v; j++) {
					//若是存在使得權重和更小的中間值k，就更新最短路徑爲通過k的路徑
					if (d[i][j] > d[i][k] + d[k][j]) {
						d[i][j] = d[i][k] + d[k][j];
						prev[i][j]=k;
					}
				}
			}
		}

		//四捨五入距離
		for (int i = 0; i < v; i++) {
			for (int j = 0; j < v; j++) {
				d[i][j] = new BigDecimal(d[i][j]).setScale(2,
						RoundingMode.HALF_UP).doubleValue();
			}
		}

		//檢測負權重環的方式很簡單，就是判斷全部i->i的距離d[i][i]，若是存在小於0的，表示這個i->i的環路的權重和造成了一個負值，也就是存在這個負權重
		//在以前的其餘最短路徑算法中，沒法經過這個方法來檢測負環，由於以前路徑距離都是保存在一個一維數組中，相等於只能檢測d[0][0]，沒法檢測每一個d[i][i]
		for(int i=0;i<v;i++){
			if(d[i][i]<0)
				negativeCycle=true;
		}
	}

	/**
	 * 
	 * @Title: hasNegativeCycle
	 * @Description: 是否擁有負權重環
	 * @param @return 設定文件
	 * @return boolean 返回類型
	 * @throws
	 */
	public boolean hasNegativeCycle() {
		return negativeCycle;
	}

	/**
	 * 
	 * @Title: distTo
	 * @Description: a->b最短路徑的距離
	 * @param @param a
	 * @param @param b
	 * @param @return 設定文件
	 * @return double 返回類型
	 * @throws
	 */
	public double distTo(int a, int b) {
		if (hasNegativeCycle())
			throw new RuntimeException("有負權重環，不存在最短路徑");
		return d[a][b];
	}
	
	/**
	 * 
	 * @Title: printShortestPath
	 * @Description: 打印a->b最短路徑
	 * @param @return 設定文件
	 * @return Iterable<Integer> 返回類型
	 * @throws
	 */
	public boolean printShortestPath(int a,int b){
		if (hasNegativeCycle()){
			System.out.print("有負權重環，不存在最短路徑");
		}else if(a==b)
			System.out.println(a+"->"+b);
		else{
			System.out.print(a+"->");
			path(a,b);
			System.out.print(b);
		}
		return true;
	}

	private void path(int a, int b) {
		int k=prev[a][b];
		
		if(k==-1){
			return;
		}
		
		path(a,k);
		System.out.print(k+"->");
		path(k,b);
	}
	
	

	/**
	 * 
	 * @Title: addEdge
	 * @Description: 添加邊
	 * @param @param a
	 * @param @param b
	 * @param @param w 設定文件
	 * @return void 返回類型
	 * @throws
	 */
	public void addEdge(int a, int b, double w) {
		d[a][b] = w;
	}

	public static void main(String[] args) {
		// 不含負權重環的文本數據
		String text1 = "F:\\算法\\attach\\tinyEWDn.txt";
		// 含有負權重環的文本數據
		String text2 = "F:\\算法\\attach\\tinyEWDnc.txt";

		In in = new In(text1);

		int n = in.readInt();
		FloydWarshall f = new FloydWarshall(n);

		int e = in.readInt();

		for (int i = 0; i < e; i++) {
			f.addEdge(in.readInt(), in.readInt(), in.readDouble());
		}

		f.findShortestPath();

		int s = 0;
		for (int i = 0; i < n; i++) {
			System.out.println(s + "到" + i + "的距離爲:" + f.distTo(s, i));
			f.printShortestPath(s, i);
			System.out.println();
		}
	}

}

若是採用負權重環圖，則會拋出異常，提示負環並表示無最短路徑

若是採用不含負環的圖，則會打印以下內容（目前以s=0做測試，其餘點做爲原點的最短路徑能夠自行嘗試）：

0到0的距離爲:0.0
0->0

0到1的距離爲:0.93
0->2->7->3->6->4->5->1
0到2的距離爲:0.26
0->2
0到3的距離爲:0.99
0->2->7->3
0到4的距離爲:0.26
0->2->7->3->6->4
0到5的距離爲:0.61
0->2->7->3->6->4->5
0到6的距離爲:1.51
0->2->7->3->6
0到7的距離爲:0.6
0->2->7