7-1 最短路径之Floyd

请缩写程序，实现求有向网的最短路径的Floyd算法，因地点可能够是淡泊湖，宁静楼等等，这里简化成编号，要求能够查询出任意两点（用编号表示）间的最短路径及最小距离。

说明：1）顶点个数上限不超过100；2）距离权值上限不超过9998；

输入样例:
第一行，两个整数：vN和eN（图中顶点数和和边数）。
接下来是vN条边的信息：起点，终点，权值（三个数一行，以空格分隔）；
最后两行是待查询的两组``起点与终点的编号（每行一个查询，起点与终点编号间也是空格分隔）。

6 8
0 5 100
0 2 10
0 4 30
1 2 5
2 3 50
3 5 10
4 3 20
4 5 60
0 5
2 0

（三块信息：顶点数和边数；边的信息；两组需要查询的顶点信息）

输出样例:
共输出三行，前两行分别输出两组查询的结果：先是起点到终点的路径说明，再是距离，中间以冒号分隔。如果两个点间不可达，输出距离-1。最后一行是整个可达距离中最大距离的描述(若有多组，输入位置稍前的一组，注意：不包括不可到达的无穷大)。

0->4->3->5:60
2->0:-1
1->2->3->5:65

	0	1	2	3	4	5	6
0	0	inf	10	inf	30	100	inf
1	inf	0	5	inf	inf	inf	inf
2	inf	inf	0	50	inf	inf	inf
3	inf	inf	inf	0	inf	10	inf
4	inf	inf	inf	20	0	60	inf
5	inf	inf	inf	inf	inf	0	inf
6	inf	inf	inf	inf	inf	inf	0

	0	1	2	3	4	5	6
0	0	inf	10	60(0-2-3)	30	70(0-2-3-5)	inf
1	inf	0	5	55(1-2-3)	inf	65(1-2-3-5)	inf
2	inf	inf	0	50	inf	inf	inf
3	inf	inf	inf	0	inf	10	inf
4	inf	inf	inf	20	0	60	inf
5	inf	inf	inf	inf	inf	0	inf
6	inf	inf	inf	inf	inf	inf	0

import java.util.*;

class AdjMatrix{
    int vexnum,edgenum;
    int Matrix[][];
    int path[][];
  
    public AdjMatrix(int vexnum,int edgenum){
        this.vexnum=vexnum;
        this.edgenum=edgenum;
        Matrix=new int[vexnum][vexnum];
        path=new int[vexnum][vexnum];
      
        for(int i=0;i<vexnum;i++){
            for(int j=0;j<vexnum;j++){
                if(i==j)
                    Matrix[i][j]=0;
                else Matrix[i][j]=1000000;
                path[i][j]=j;
            }
        }
    }
    public void Print(int source,int end){
        int w=Matrix[source][end];
        int e=path[source][end];
        System.out.print(source);
        while(e!=end){
            System.out.print("->"+e);
            e=path[e][end];
        }
        System.out.print("->"+end);
        if(w==1000000)
            System.out.println(":-1");
        else System.out.println(":"+w);
    }
    public void floyd(){
        for(int k=0;k<vexnum;k++){
            for(int i=0;i<vexnum;i++){
                for(int j=0;j<vexnum;j++){
                    if(Matrix[i][j]>Matrix[i][k]+Matrix[k][j]){
                        Matrix[i][j]=Matrix[i][k]+Matrix[k][j];
                        path[i][j]=path[i][k];
                    }
                }
            }
        }
    }
    
}
public class Main{
    
    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);
        AdjMatrix adjMatrix=new AdjMatrix(sc.nextInt(), sc.nextInt());
        for(int i=0;i<adjMatrix.edgenum;i++){
            adjMatrix.Matrix[sc.nextInt()][sc.nextInt()]=sc.nextInt();
        }    
        for(int x=0;x<2;x++){
            int s=sc.nextInt();
            int e=sc.nextInt();
            adjMatrix.floyd();
            adjMatrix.Print(s, e);
        }
        int max=0;
        int x=0;
        int y=0;
        for(int i=0;i<adjMatrix.vexnum;i++){
            for(int j=0;j<adjMatrix.vexnum;j++){
                if(adjMatrix.Matrix[i][j]==1000000)
                    continue;
                if(max<adjMatrix.Matrix[i][j]){
                    max=adjMatrix.Matrix[i][j];
                    x=i;
                    y=j;
                }
            }
        }
        adjMatrix.Print(x, y);

    }
}