Floyd算法

动态规划思想：

记<a, b>: a到b的路径

遍历a,b以外的所有k点：若路径长度矩阵中 length(<a, k>)+length(<k, b>)  < length(<a, b>) , 则更新 length(<a, b>)  同时记录下<a, b>的中间点k在路径矩阵中。算法复杂度:   n为顶点个数，邻接矩阵n x n

在floyd算法中是以k为最外围的循环条件进行更新，（i,j）作为内部循环条件进行更新，依次k的循环即完成更新

疑问：

ps: 确实没看懂为什么k循环一次就能完成更新，以第一次k=0时的更新为例；即使 length(<a, 0>)+length(<0, b>)  < length(<a, b>) ，也不能说当前的length(<0, b>)（或length(<a, 0>)）就是length(<0, b>)（或length(<a, 0>)）的最优值啊？？？

如果哪位大神懂，请不吝赐教！！！

更新：

刚好https://blog.csdn.net/ljhandlwt/article/details/52096932有这个解释！！！

代码实现：

基于下图实例：

图片来源

package ali.exercise;

public class Main {
	
	final static int INF = 1000;
	
	public static void main(String[] args) {
		int[][] a = { 	{ INF, 12,  INF, INF, INF,  16, 14  },
		   				{ 12 , INF,  10, INF, INF,   7, INF },
		   				{ INF, 10,  INF,   3,   5,   6, INF },
		   				{ INF, INF,	  3, INF,   4, INF, INF },
		   				{ INF, INF,   5,   4, INF,   2,   8 },
		   				{  16,   7,	  6, INF,   2, INF,   9 },
		   				{  14, INF, INF, INF,   8,	 9,	INF }
		   			};
		
		
		//路径矩阵初始化为-1
		int[][] p = new int[a.length][a[0].length];
		for (int i = 0; i < p.length; i++) {
			for (int j = 0; j < p[i].length; j++) {
				p[i][j] = -1;
			}
		}
		
		//以第k个节点作为中间节点优化矩阵
		for (int k = 0; k < a.length; k++) {
			for (int i = 0; i < a.length; i++) {
				for (int j = 0; j < a.length; j++) {
					//不计算第k行   because:(k,m)=(k,k)+(k,m)没有意义
					//不计算第k列   because:(m,k)=(m,k)+(k,k)没有意义
					//不计算对角线  because:计算(m,m)没有意义
					if(i!=j && i!=k && j!=k && a[i][k]+a[k][j] < a[i][j]) {
						a[i][j] = a[i][k]+a[k][j];
						p[i][j] = k;
					}
				}
			}
		}
		dispPath(a, p);
		//System.out.println(shortestPath(p,0,3));
	}
	/*
	 * 输出所有矩阵的最优路劲和权值
	 */
	private static void dispPath(int[][] a, int[][] p) {
		for (int i = 0; i < a.length; i++) 
			for (int j = i+1; j < a.length; j++) 
				System.out.printf("v%d-v%d weight: %2d path: %-20s\n",i+1,j+1,a[i][j],shortestPath(p,i,j));  
	}
	/*
	 * 求最优路径
	 */
	private static String shortestPath(int[][] p, int i, int j) {
		StringBuilder sb = new StringBuilder("v");
		if(p[i][j] == -1) {
			sb.append(i+1);
			sb.append("->v");
			sb.append(j+1);
			return sb.toString();
		}
		String s0 = shortestPath(p, i, p[i][j]);
		//s0..-4是为去掉重复的部分
		return s0.substring(0, s0.length()-4) + "->" + shortestPath(p, p[i][j], j) ;
	}


}