每对顶点的最短路径 : Johnson 算法

import org.apache.commons.lang.builder.ToStringBuilder;

/**
 * 稀疏图上的Johnson算法 结合 BellmanFord 和 Dijkstra 算法
 * 
 */
public class Johnson {
	static final int M = 10000; // unreachable

	/**
	 * <pre>
	 * @param edges : G(V,E)
	 * @param dist : 计算的最短路径结果
	 * @param p : 记录前序节点
	 * @param s : 源点
	 * @return
	 * </pre>
	 */
	static boolean bellmanFord(int[][] edges, int[] dist, int[] p, int s) {
		int n = edges.length;
		if (dist == null) {
			dist = new int[n];
		}
		if (p == null) {
			p = new int[n];
		}
		// init
		for (int i = 0; i < n; i++) {
			dist[i] = M;
			p[i] = -1;
		}
		dist[s] = 0;
		p[s] = -1;

		// 最短路径中最多含有n-1条边
		for (int cnt = 1; cnt < n; cnt++) {
			for (int i = 0; i < n; i++) {
				for (int j = 0; j < n; j++) {
					if (edges[i][j] < M && dist[j] > (dist[i] + edges[i][j])) {
						dist[j] = dist[i] + edges[i][j];
						p[j] = i;
					}
				}
			}
		}

		// 判断是否存在负权环
		for (int i = 0; i < n; i++) {
			for (int j = 0; j < n; j++) {
				if (edges[i][j] < M) {
					if (dist[j] > dist[i] + edges[i][j]) // 存在
						return false;
				}
			}
		}
		return true;
	}

	/**
	 * <pre>
	 * @param edges : G(V,E)
	 * @param dist : 计算的最短路径结果
	 * @param p : 记录前序节点
	 * @param s : 源点
	 * </pre>
	 */
	static void dijkstra(int[][] edges, int[] dist, int[] p, int s) {
		int n = edges.length;
		if (dist == null) {
			dist = new int[n];
		}
		if (p == null) {
			p = new int[n];
		}

		// init
		boolean[] visited = new boolean[n];
		for (int i = 0; i < n; i++) {
			dist[i] = Integer.MAX_VALUE;
			p[i] = -1;
		}
		// 源点的值置为0
		dist[s] = 0;
		p[s] = -1;

		// n个点,n次循环
		int cnt = n;
		while (cnt > 0) {
			cnt--;
			int idx = -1;
			int min = Integer.MAX_VALUE;
			// 选取dist中值最小的一个点, 用最小堆更好
			for (int i = 0; i < n; i++) {
				if (!visited[i] && min > dist[i]) {
					min = dist[i];
					idx = i;
				}
			}
			// union
			visited[idx] = true;
			// 计算最短路径
			for (int j = 0; j < n; j++) {
				if (dist[j] > (dist[idx] + edges[idx][j])) {
					dist[j] = dist[idx] + edges[idx][j];
					p[j] = idx;
				}
			}
		}

	}

	/**
	 * 根据索引,返回对应的节点名称
	 * 
	 * @param i
	 * @return
	 */
	static char node(int i) {
		return (char) ('A' + i);
	}

	/**
	 * 打印从u->v的最短路径
	 * 
	 * <pre>
	 * @param p : 记录前序节点
	 * @param u : 起始节点
	 * @param v : 终止节点
	 * @param d : 最短路径值
	 * </pre>
	 */
	static void printPath(int[] p, int u, int v, int d) {

		if (d == M) {
			System.out.printf("%c -> %c (∞) : \n", node(u), node(v));
			return;
		} else {
			System.out.printf("%c -> %c (%d) : ", node(u), node(v), d);
			StringBuilder sb = new StringBuilder();
			sb.append(node(v));
			while (p[v] != -1) {
				sb.insert(0, node(p[v]) + " - ");
				v = p[v];
			}
			System.out.println(sb.toString());
		}
	}

	/**
	 * <pre>
	 * @param _edges
	 * 1.通过增加一个s节点,并增加s->V的路径(edge[s][v] = 0; edge[v][s] = M;),并建立有向图G'
	 * 2.对于G', 用Bellman-Ford 算法判断是否存在负权环
	 * 3.如果存在,退出,不存在,计算最短路径(int[] h)和前序节点
	 * 4.Reweighting, W(u,v)' = W(u, v) + h(u) - h(v);
	 * 5.通过Dijkstra算法,计算图G'以每个节点为源点的最短路径
	 * 6.对计算得到的最短路径值进行恢复dist[u][v] = d[v] - h[u] + h[v];
	 * </pre>
	 */
	static void johnson(int[][] _edges) {
		int _n = _edges.length;

		//增加源点s, 构建图G'
		int s = _n;
		int n = _n + 1;
		int[][] edges = new int[n][n];
		int[][] dist = new int[_n][_n];
		for (int i = 0; i < _n; i++) {
			for (int j = 0; j < _n; j++) {
				edges[i][j] = _edges[i][j];
				dist[i][j] = M;
			}
			edges[i][_n] = M;
		}

		//判断是否存在负权环,并且计算h
		int[] h = new int[n];
		boolean noNegativeCycle = bellmanFord(edges, h, null, s);
		if (!noNegativeCycle) {
			System.out.println("G(V,E) exist negative cycle!");
			return;
		}

		//Reweighting
		for (int i = 0; i < _n; i++) {
			for (int j = 0; j < _n; j++) {
				if (i != j && _edges[i][j] < M)
					edges[i][j] = _edges[i][j] + h[i] - h[j];
			}
		}
		for (int i = 0; i < _n; i++) {
			for (int j = 0; j < _n; j++) {
				_edges[i][j] = edges[i][j];
			}
		}

		// 通过Dijkstra算法,计算每个顶点为源点的最短路径
		for (int i = 0; i < _n; i++) {
			int[] d = new int[_n];
			int[] p = new int[_n];
			dijkstra(_edges, d, p, i);
			for (int j = 0; j < _n; j++) {
				//数据恢复,得到最短路径
				dist[i][j] = d[j] - h[i] + h[j];
				//print
				printPath(p, i, j, dist[i][j]);
			}
			System.out.println();
		}
	}

	public static void main(String[] args) {
//		int[][] edges = { 
//				{ 0, 3, 8, M, -4 }, 
//				{ M, 0, M, 1, 7 }, 
//				{ M, 4, 0, M, M }, 
//				{ 2, M, -5, 0, M },
//				{ M, M, M, 6, 0 } 
//			};
		
		int[][] edges = {
				{0,	M,	M,		M, M, M, 9},
				{20, 	0, 	10,	30, M, M, M},
				{M, 	M, 0, 	M, 5, M, 18},
				{M, 	M, M, 	0, M, M, M},
				{M, 	M, M, 	12, 0, M, 15},
				{M, 	M, M, 	M, 8, 0, 10},
				{M, 	M, 18, 	M, M, M, 0}
		};

		johnson(edges);

	}
}