Floyd求最短路径

Floyd算法

 

动态规划求两点之间最短路径。

假设i，j是所求顶点编号，使用数组D来存储。

D【i】【j】即为所求结果。

D【i】【j】=min{D【i】【j】，D【i】【k】+D【k】【j】}（其中，k为1~n）

D【k】【i】【j】表示i和j之间可以通过编号为1···k的节点的最短路径。初值D【k】【i】【j】为初始邻接矩阵。

例：现在要求2-->1的最短路。总顶点数为4个。

K会从1遍历到4，查看从2到1，中间经过哪个点，可使得路径最优。

如果不存在，则取原值。

一．K在最外层

K在最外层的解释：

例如求2-->1,的时候。

当k=4，所求路径为 2-->4-->1

而2-->4,在前面k=3的那次循环中已经求出来了。2-->4可以通过2-->3-->4求得，为：4.

所以代入上面的 2-->4-->1 等于 4+5=9.

总的来说就是k是DP的阶段，因此要写最外面。

K会用到k-1的结果。

二．K在最里面，则i和j需要从第N个点开始求

原因也和上面的差不多，本层的状态需要上一层的状态，而上一层还没计算，结果就错了。

例:求2-->1.

当i=2，j=1的时候。

当k=3的时候，2-->3为3.而3-->1此时还没计算出最优值。（因为现在i=2，要i=3才会计算出3-->1的最优值。）所以此时D【3】【1】存储了7，为初始化的直接结果。所以D【2】【1】就会等于D【2】【3】+D【3】【1】=9.

然后i继续++，变成了3.知道循环结束，i=2的错误结果都不会被重新计算出正确结果并覆盖掉错误结果。

所以需要从i=4，j=4开始。

 

总代码：

package floyd;

public class floyd {
	static final int N=8;
	static final int MAX = 9999999;
	static int from=2,to=5;
	static int result[][]=new int[N+1][N+1];
	static int map[][]={
				{0,0,0,0,0,0,0,0,0},
				{0,0,17,13,0,21,0,0,0},
				{0,0,0,0,11,0,13,0,0},
				{0,7,0,0,22,0,0,0,13},
				{0,0,0,0,0,0,1,1,18},
				{0,0,0,0,0,0,0,10,0},
				{0,0,0,0,0,0,0,0,0},
				{0,0,0,1,0,2,0,0,15},
				{0,0,0,3,0,0,21,0,0}
		}; 
	/*static int map[][]={
			{0,0,0,0,0},
			{0,0,2,6,4},
			{0,0,0,3,0},
			{0,7,0,0,1},
			{0,5,0,12,0}
	}; */
	public static void main(String args[])
	{
		
		for(int i=1;i<=N;i++)
		{
			for(int j=1;j<=N;j++)
			{
				if(i==j) result[i][j]=0;
				else if(map[i][j]!=0) result[i][j]=map[i][j];
				else result[i][j]=MAX;
			}
		}
		
		for(int i=N;i>=1;i--)
			for(int j=N;j>=1;j--)
				for(int k=1;k<=N;k++)
					if(result[i][j]>result[i][k]+result[k][j])
						result[i][j]=result[i][k]+result[k][j];
		
		
		/*for(int k=1;k<=N;k++)
			for(int i=1;i<=N;i++)
				for(int j=N;j>=1;j--)
					if(result[i][j]>result[i][k]+result[k][j])
						result[i][j]=result[i][k]+result[k][j];
		*/
		for(int i=1;i<=N;i++){
			for(int j=1;j<=N;j++)
				System.out.print(" "+result[i][j]);
			System.out.println();
		}
		
		System.out.println(result[from][to]);
		
	}
}

-------------------------------------------------------------------2018/1/5--------------------------------------------------------

上面的程序只能打印出最优路径权值，不能打印出最短路径。下面增加一个打印from到to的最短路。

public static void prin(int from,int to)
	{
		if(lujin[from][to]==0){
			System.out.print(" "+to);
			return;
		}
		prin(from,lujin[from][to]);
		prin(lujin[from][to],to);
	}

使用一个lujin数组来存放 “i到j在第k处断开”  既lujin【i】【j】=k。

传入from和to，然后把路劲分为2半，继续递归下去。

例如：2-->1,中间经过3. 

即为：2--3--1。

所以递归2---3  和 3---1.

一直到lujin【i】【j】为0，说明两个点为邻接点，无法再断开。

总代码：

package floyd;

public class floyd {
	static final int N=8;
	static final int MAX = 9999999;
	static int from=1,to=6;
	static int result[][]=new int[N+1][N+1];
	static int lujin[][]=new int[N+1][N+1];
	static int map[][]={
				{0,0,0,0,0,0,0,0,0},
				{0,0,17,13,0,21,0,0,0},
				{0,0,0,0,11,0,13,0,0},
				{0,7,0,0,22,0,0,0,13},
				{0,0,0,0,0,0,1,1,18},
				{0,0,0,0,0,0,0,10,0},
				{0,0,0,0,0,0,0,0,0},
				{0,0,0,1,0,2,0,0,15},
				{0,0,0,3,0,0,21,0,0}
		}; 
/*	static int map[][]={
			{0,0,0,0,0},
			{0,0,2,6,4},
			{0,0,0,3,0},
			{0,7,0,0,1},
			{0,5,0,12,0}
	}; */
	public static void main(String args[])
	{
		
		for(int i=1;i<=N;i++)
		{
			for(int j=1;j<=N;j++)
			{
				if(i==j) result[i][j]=0;
				else if(map[i][j]!=0){
					result[i][j]=map[i][j];
					//lujin[i][j]=0;
				}
				else result[i][j]=MAX;
			}
		}
		
		for(int i=N;i>=1;i--)
			for(int j=N;j>=1;j--)
				for(int k=1;k<=N;k++)
					if(result[i][j]>result[i][k]+result[k][j])
					{
						result[i][j]=result[i][k]+result[k][j];
						lujin[i][j]=k;
					}
		
		
		/*for(int k=1;k<=N;k++)
			for(int i=1;i<=N;i++)
				for(int j=N;j>=1;j--)
					if(result[i][j]>result[i][k]+result[k][j])
						result[i][j]=result[i][k]+result[k][j];
		*/
		System.out.println("权值图为:");
		for(int i=1;i<=N;i++){
			for(int j=1;j<=N;j++)
				System.out.print(" "+result[i][j]);
			System.out.println();
		}
		System.out.println();
		System.out.println("路径图为:");
		
		for(int i=1;i<=N;i++){
			for(int j=1;j<=N;j++)
				System.out.print(" "+lujin[i][j]);
			System.out.println();
		}
		System.out.println();
		System.out.println(from+"到"+to+"的最优路径和权值为：");
		
		System.out.print(from);
		prin(from,to);
		
		System.out.println();
		System.out.println(result[from][to]);
	}
	
	public static void prin(int from,int to)
	{
		if(lujin[from][to]==0){
			System.out.print(" "+to);
			return;
		}
		prin(from,lujin[from][to]);
		prin(lujin[from][to],to);
	}
}