算法導論——有向無環加權圖的最短路徑（使用拓撲排序）

package org.loda.graph;

import org.loda.structure.Stack;
import org.loda.util.In;

/**
 * 
 * @ClassName: NoCycleSP
 * @Description: 有向無環圖的最短路徑算法
 * 
 * 無環圖能夠採用拓撲排序來處理，進行拓撲排序中不會有排名靠後的指向排名靠前的狀況，因此拓撲排序的第一個節點是沒法從其餘節點抵達的
 * 
 * 無環權重有向圖的算法時間複雜度能夠高達O(V+E)，比Dijkstra算法更好，而且能解決負數權重問題，不過他須要有向圖是無環的
 * 
 * @author minjun
 * @date 2015年5月28日 上午9:47:26
 * 
 */
public class NoCycleSP {

	/**
	 * 原點
	 */
	private int s;

	/**
	 * dist[i]表示s->i的距離
	 */
	private double[] dist;

	/**
	 * 最短路徑上的前驅頂點
	 */
	private int[] prev;

	public NoCycleSP(WeightDigraph g, int s) {
		int v = g.v();
		this.s = s;

		dist = new double[v];

		prev = new int[v];

		for (int i = 0; i < v; i++) {
			prev[i] = -1;
			dist[i] = Double.POSITIVE_INFINITY;
		}

		dist[s] = 0.0;

		// 將權重有向圖轉成無權有向圖圖，而後進行拓撲排序
		Topological top = new Topological(g.toDigraph());

		for (int i : top.order()) {
			relax(i, g);
		}
	}

	/**
	 * 
	 * @Title: relax
	 * @Description: 鬆弛某個頂點周圍的邊
	 * @param @param i
	 * @param @param g 設定文件
	 * @return void 返回類型
	 * @throws
	 */
	private void relax(int i, WeightDigraph g) {
		for (Edge edge : g.adj(i)) {
			int j = edge.otherSide(i);

			if (dist[j] > dist[i] + edge.weight()) {
				dist[j] = dist[i] + edge.weight();
				prev[j] = i;
			}
		}
	}

	/**
	 * 
	 * @Title: distTo
	 * @Description: s->v的最短距離
	 * @param @param v
	 * @param @return 設定文件
	 * @return double 返回類型
	 * @throws
	 */
	public double distTo(int v) {
		return dist[v];
	}

	/**
	 * 
	 * @Title: pathTo
	 * @Description: 最短路徑
	 * @param @param v
	 * @param @return 設定文件
	 * @return Iterable<Integer> 返回類型
	 * @throws
	 */
	public Iterable<Integer> pathTo(int v) {
		if (distTo(v) == Double.POSITIVE_INFINITY)
			return null;

		Stack<Integer> path = new Stack<Integer>();

		for (int i = v; i != -1; i = prev[i]) {
			path.push(i);
		}
		return path;
	}

	public static void main(String[] args) {
		WeightDigraph g = new WeightDigraph(new In(
				"F:\\算法\\attach\\tinyEWDAG.txt"));
		
		//因爲沒法從其餘節點到達5節點（拓撲排序第一個節點），因此這裏咱們採用5節點做爲第一個節點，來觀察全部的可達路徑
		NoCycleSP d = new NoCycleSP(g, 5);

		for (int i = 0; i < g.v(); i++) {
			Iterable<Integer> path = d.pathTo(i);
			if (path == null) {
				System.out.println("從原點" + d.s + "到" + i + "沒有可達路徑");
			} else {
				System.out.println("從原點" + d.s + "到" + i + "的最短距離爲："
						+ d.distTo(i));
				System.out.print("路徑爲：");
				for (int j : d.pathTo(i)) {
					System.out.print(j + "->");
				}
				System.out.println();
			}
		}
	}
}

文本數據：

8
13
5 4 0.35
4 7 0.37
5 7 0.28
5 1 0.32
4 0 0.38
0 2 0.26
3 7 0.39
1 3 0.29
7 2 0.34
6 2 0.40
3 6 0.52
6 0 0.58
6 4 0.93

這個無環圖的輸出結果爲：

從原點5到0的最短距離爲：0.73
路徑爲：5->4->0->
從原點5到1的最短距離爲：0.32
路徑爲：5->1->
從原點5到2的最短距離爲：0.6200000000000001
路徑爲：5->7->2->
從原點5到3的最短距離爲：0.61
路徑爲：5->1->3->
從原點5到4的最短距離爲：0.35
路徑爲：5->4->
從原點5到5的最短距離爲：0.0
路徑爲：5->
從原點5到6的最短距離爲：1.13
路徑爲：5->1->3->6->
從原點5到7的最短距離爲：0.28
路徑爲：5->7->