Java 如何列出Floyd Warshall算法中传递的顶点

在我的算法（floyd warshall）计算最短路径时，我似乎想不出一种方法来列出通过的顶点。有人告诉我必须使用递归，但我不知道如何使用递归。请给出伪代码/示例，非常感谢

    import java.util.*;
    public class Main{
        public static final int INF = 9999999;
        public static int[][] path;
        public static int[] tax;
        public static void main(String[] adsf){
            Scanner pp = new Scanner(System.in);
            int testCases = pp.nextInt();
            pp.nextLine();
            pp.nextLine();
            while(testCases-- >0){
                String[] s1 = pp.nextLine().split(" ");
                int size = s1.length;
                path = new int[size][size];
                for(int i = 0; i < path.length; i++)
                    Arrays.fill(path[i],INF);
                tax = new int[size];
                for(int j = 0; j < path[0].length; j++){
                    path[0][j] = Integer.parseInt(s1[j]);
                    if(path[0][j]==-1)path[0][j]=INF;
                }
                for(int i = 1; i < path.length;i++){
                    s1 = pp.nextLine().split(" ");
                    for(int j = 0; j < path[0].length; j++){
                        path[i][j] = Integer.parseInt(s1[j]);
                        if(path[i][j]==-1)path[i][j]=INF;
                    }
                }
                for(int k=0; k<tax.length;k++){
                    tax[k] = pp.nextInt();
                } pp.nextLine();    
                sssp();
                }
                int x,y;
                while(pp.hasNextInt()){
                    x=pp.nextInt();
                    y=pp.nextInt();
                    int cost = path[x-1][y-1];
                    System.out.println((x-1)+" "+(y-1)+" "+cost);
                }
            }
        }
        public static void sssp(){
            for(int k=0;k<path.length;k++){
                for(int i=0;i<path.length;i++){
                    for(int j=0;j<path.length;j++){
                        path[i][j] = Math.min(path[i][j],path[i][k]+path[k][j]);
                    }
                }   
            }
        }
    }

import java.util.*；
公共班机{
公共静态最终int INF=9999999；
公共静态int[][]路径；
公共税收；
公共静态void main（字符串[]adsf）{
扫描仪pp=新扫描仪（System.in）；
int testCases=pp.nextInt（）；
pp.nextLine（）；
pp.nextLine（）；
而（测试用例-->0）{
字符串[]s1=pp.nextLine（）.split（“”）；
int size=s1.1长度；
路径=新整数[size][size]；
for（int i=0；i对于（int k=0；k您不需要使用递归进行路径重建（事实上，您在Java中不必使用递归，只是碰巧使用它来解决某些问题更方便，包括这个问题）

为了能够计算出除了长度之外的最短路径，您需要第二个2D数组来存储路径中节点的后续节点。请看，我所说的数组在伪代码中称为
next

回想一下，该算法的逻辑如下：“如果通过
k
从
i
到
j
的速度比通过任何先前发现的路径从
i
到
j
的速度快，那么使用
k
的路径作为当前最短路径。”。现在您需要做的就是将通过
k
的决定存储在其他数组中，如下所示：

if (path[i][k] + path[k][j] < path[i][j]) {
    path[i][j] = path[i][k]+path[k][j];
    next[i][j] = k;
}

更像是为考试做准备的东西？评论员？明天可能会出现。哈哈哈。天哪。为什么我没想到呢？可能我在过去的一个小时里花了很多时间试图学习递归。哈哈。他们教过我们递归，但我从来都不觉得使用它舒服（可怕的、可怕的调试非常令人沮丧）.非常感谢！嗯，我马上就接受你的回答。Stackoverflow现在还不会让我这么做！哦，这就是他们的意思。非常感谢。：）当没有从I到k的直接路径或从I到k的最短路径不是I->k时，应该是next[I][j]=next[I][k吗？
String GetPath (int i, int j) {
    if (path[i][j] == INF) return "no path";
    int intermediate = next[i][j];
    if (intermediate < 0) return " ";
    return GetPath(i,intermediate) + intermediate + GetPath(intermediate,j);
}