乘地铁方案的最优选择二（票价，距离）Floyd算法

上一篇文章中是以Dijkstra算法实现的查找最短路径，还可以用Floyd算法实现。

在原类中添加一个方法：

public int findByFloyd(T start, T stop) {
		FLOYD floyd = new FLOYD(subTrainMatrix);
		int startPos = getPosInvertex(start);
		int stopPos = getPosInvertex(stop);
		int[] path = floyd.getPath(startPos, stopPos);
		StringBuilder sb = new StringBuilder();
		System.out.print("The path from " + start + " to " + stop + " : ");
		for (int i : path) {
			sb.append(vertex.get(i) + " --> ");
		}
		sb.delete(sb.lastIndexOf(" --> "), sb.length());
		System.out.println(sb.toString());
		return path.length;
	}

添加一个FLOYD类实现：

package com.patrick.bishi;

/**
 * 以无向图G为入口，得出任意两点之间的路径长度length[i][j]，路径path[i][j][k]， 途中无连接得点距离用M表示，点自身也用0表示
 * 
 * @author patrick
 * 
 */
public class FLOYD {
	int[][] length = null;// 任意两点之间路径长度
	int[][][] path = null;// 任意两点之间的路径

	public FLOYD(int[][] G) {
		int row = G.length;// 图G的行数
		int[][] spot = new int[row][row];// 定义任意两点之间经过的点
		int[] onePath = new int[row];// 记录一条路径
		this.length = G;
		path = new int[row][row][];

		for (int i = 0; i < row; i++)
			// 初始化为任意两点之间没有路径
			for (int j = 0; j < row; j++)
				spot[i][j] = -1;

		for (int i = 0; i < row; i++)
			// 假设任意两点之间的没有路径
			onePath[i] = -1;

		for (int u = 0; u < row; ++u)
			for (int v = 0; v < row; ++v)
				for (int w = 0; w < row; ++w)
					if (length[v][w] > length[v][u] + length[u][w]) {
						length[v][w] = length[v][u] + length[u][w];// 如果存在更短路径则取更短路径
						spot[v][w] = u;// 把经过的点加入
					}

		for (int i = 0; i < row; i++) {
			// 求出所有的路径 i -> j
			int[] point = new int[1];// 经过的点数
			for (int j = 0; j < row; j++) {
				point[0] = 0;
				onePath[point[0]++] = i;// 起i点为自身
				outputPath(spot, i, j, onePath, point);// 更新onePath
				path[i][j] = new int[point[0]];
				for (int s = 0; s < point[0]; s++)
					path[i][j][s] = onePath[s];
			}
		}
	}

	private void outputPath(int[][] spot, int i, int j, int[] onePath,
			int[] point) {
		// 输出i 到j 的路径的实际代码,point[]记录一条路径的长度
		if (i == j)
			return;
		if (spot[i][j] == -1)
			onePath[point[0]++] = j;// 中间没有经过其他节点，即直接到达
		else {
			outputPath(spot, i, spot[i][j], onePath, point);
			outputPath(spot, spot[i][j], j, onePath, point);
		}
	}

	public int[] getPath(int start, int stop) {
		return path[start][stop];
	}

	private static final int M = 99999;

	public static void main(String[] args) {
		int data[][] = {// 邻接矩阵
		{ 0, 3, 2000, 7, M }, { 3, 0, 4, 2, M }, { M, 4, 0, 5, 4 },
				{ 7, 2, 5, 0, 6 }, { M, M, 4, 6, 0 } };

		FLOYD floyd = new FLOYD(data);

		for (int i = 0; i < data.length; i++) {
			for (int j = i; j < data[i].length; j++) {
				System.out.print("From " + i + " to " + j + " length :"
						+ floyd.length[i][j]);
				System.out.print(", path is: ");
				for (int k = 0; k < floyd.path[i][j].length; k++)
					System.out.print(floyd.path[i][j][k] + " ");
				System.out.println();
			}
		}
	}
}

        两种方法可以比较下优劣，时间复杂度上如果将所有节点到其他节点的最短距离都求出来则都是O(n^3)，空间上当然一样，用的都是邻接矩阵保存的。