Floyd（弗洛伊德）算法求解每对顶点之间的距离（Java语言）

不要自卑，去提升实力
互联网行业谁技术牛谁是爹
如果文章可以带给你能量，那是最好的事！请相信自己
加油o~

1、Floyd（弗洛伊德）算法

Floyd（弗洛伊德）算法求解每对顶点之间的距离（Java语言）

2、设计思想：

利用两个数组
Floy【i】【j】存储 i—>j 的路径长度
Path【i】【j】存储的是 i—>j 的中间节点
利用三重循环
第一层是取不同的中间节点
第二层是取图中不同起点
第三层是取不同终点
如果floy[i][j]>floy[i][k]+floy[k][j]，则表明通过该中间节点的路径小于直接到达，经过这三次循环不断修正各个节点之间的路径，最终得到的Floy数组即为最优路径

代码：

/**
 *作者：魏宝航
 *2020年11月27日,上午10:27
 */
import org.omg.CORBA.INTERNAL;
import com.sun.jndi.url.iiopname.iiopnameURLContextFactory;
import java.io.IOException;
import java.util.Arrays;
import java.util.Collections;
import java.util.Scanner;
public class MatrixUDG {

    private char[] mVexs;
    private int[][] mMatrix;
    private int num;

    public MatrixUDG(char[] vexs, char[][] edges) {

        num = vexs.length;

        mVexs = new char[num];
        for (int i = 0; i < mVexs.length; i++)
            mVexs[i] = vexs[i];

        mMatrix = new int[num][num];
        for(int i=0;i<num;i++){
            for(int j=0;j<num;j++){
                if(edges[i][j]=='∞'){
                    mMatrix[i][j]=Integer.MAX_VALUE;
                }else{
                    mMatrix[i][j]=Integer.parseInt(edges[i][j]+"");
                }
            }
        }
    }

    public void print() {
        System.out.printf("Martix Graph:\n");
        for (int i = 0; i < mVexs.length; i++) {
            for (int j = 0; j < mVexs.length; j++){
                if(mMatrix[i][j]<Integer.MAX_VALUE){
                    System.out.printf("%d ", mMatrix[i][j]);
                }else{
                    System.out.print("∞ ");
                }
            }
            System.out.printf("\n");
        }
    }

   public void Floyd(int x,int y) {
	   int[][] floy=new int[1000][1000]; //存储i-j的距离
	   int[][] path=new int[1000][1000];//存储i-j的中间节点
	   
	   for(int i=0;i<num;i++) {
		   for(int j=0;j<num;j++) {
			   floy[i][j]=this.mMatrix[i][j];
			   if(i!=j&&this.mMatrix[i][j]<Integer.MAX_VALUE) {
				   path[i][j]=i;
			   }
			   else {
				   path[i][j]=-1;
			   }
		   }
	   }
	   for(int k=0;k<num;k++) {//中间节点
		   for(int i=0;i<num;i++) {//起点
			   for(int j=0;j<num;j++) {//终点
				   if(floy[i][j]>floy[i][k]+floy[k][j]&&(floy[i][k]+floy[k][j])>=0) {
					   floy[i][j]=floy[i][k]+floy[k][j];
					   path[i][j]=path[k][j];
				   }
			   }
		   }
	   }
	   System.out.println("每对顶点的最短路径如下：");
	   for(int i=0;i<num;i++) {
		   for(int j=0;j<num;j++) {
			   System.out.print(floy[i][j]+" ");
		   }
		   System.out.println();
	   }
	   System.out.println(x+"与"+y+"之间的最短路径为"+floy[x][y]);
   }


    public static void main(String[] args) {

        char[] vexs={'0','1','2','3'};
        char[][] edges=new char[][]{
                {'0','5','∞','7'},
                {'∞','0','4','2'},
                {'3','3','0','2'},
                {'∞','∞','1','0'},
        };
        MatrixUDG g=new MatrixUDG(vexs,edges);
        g.print();
        g.Floyd(0, 3);
    }
}