Отображение кратчайшего пути с использованием BFS в Java

Question

Это мой BFS код алгоритма.

Я могу рассчитать кратчайший путь, но почему-то не могу отобразить кратчайший путь.

Как, например, я рассчитал, что кратчайший путь от источника к месту назначения равен 2. Но я хотел бы также отобразить путь.(PlaceA -> PlaceB -> PlaceC), например.

Могу ли я узнать, как отобразить кратчайший путь, используя Java?
Пожалуйста, помогите мне!Спасибо!

 public static void main(String[] args) {
        // TODO Auto-generated method stub

        chooseNumOfVertices();
        chooseNumOfEdges();
        generateGraph();

        in.close();
    }

    private static void generateGraph() {
        int source = 0;
        int destination = 0;
        int edge = chooseEdge;

        // TODO Auto-generated method stub
        ArrayList<LinkedList<Integer>> graph = new ArrayList<LinkedList<Integer>>();
        for (int i = 0; i < limit; i++) {
            LinkedList<Integer> vertex = new LinkedList<Integer>();
            vertex.add(i);
            graph.add(vertex);
        }

        while (chooseEdge > 0) {
            // Randomize the value
            int value = new Random().nextInt(cityMapping.size());
            int value2 = new Random().nextInt(cityMapping.size());

            //
            if (value != value2 && !graph.get(value).contains(value2) && !graph.get(value2).contains(value)) {
                graph.get(value).add(value2);
                graph.get(value2).add(value);
                chooseEdge--;
            }
        }

        // Printing out the Nodes

        for (int i = 0; i < graph.size(); i++) {
            // Return each LinkedList nodes
            // System.out.println(graph.get(i));

            for (int j = 0; j < graph.get(i).size(); j++) {
                // Return each individual nodes inside LinkedList
                for (Entry<Integer, String> entry : cityMapping.entrySet()) {
                    if (entry.getKey() == graph.get(i).get(j)) {
                        //System.out.print(graph.get(i).get(j) + "-> ");
                        System.out.print(graph.get(i).get(j) + ". " + entry.getValue() + " -> ");
                    }
                }
            }
            System.out.println();
        }
        do {
        for (

                int i = 0; i < limit; i++) {
            int[] newArray = new int[limit];
            distance.add(newArray);
            predecessor.add(newArray);
        }
        long time = System.nanoTime();
        System.out.println("Searching BFS");
        System.out.println("--------------------------------------------");

        for (int i = 0; i < limit; i++) {
            BFS(graph, i);
        }

        long CPUTime =  (System.nanoTime() - time);
        System.out.println("CPU Time for BFS for " + limit + "vertices and " + edge + "edges (in ns): " + CPUTime);

        System.out.print("Enter -1 to exit! Enter source vertex (between 0 to " + (limit - 1) + ") : ");

        source = in.nextInt();
        if (source == -1) {
            System.out.print("System terminating...");
            break;
        }
        System.out.print("Enter destination vertex (between 0 to " + (limit - 1) + ") : ");
        destination = in.nextInt();

        System.out.println("Distance from " + source + " to " + destination + " is: " +

                getDistance(source, destination));
        System.out.println("The Predecessor of the path from " + source + " to " + destination + " is: "
                + getPredecessor(source, destination));


        } while (source != -1);
    }

    private static void BFS(ArrayList<LinkedList<Integer>> graph, int i) {
        // TODO Auto-generated method stub
        boolean[] mark = new boolean[graph.size()]; 
        Queue<Integer> L = new ArrayBlockingQueue<Integer>(graph.size()); //Queue

        L.add(i);
        mark[i] = true; 
        Arrays.fill(predecessor.get(i), -1);
        Arrays.fill(distance.get(i), -1);
        distance.get(i)[i] = 0;

        while (!L.isEmpty()) {
            int vertex = L.remove(); 

            for (int i1 = 0; i1 < graph.get(vertex).size(); i1++) {
                int v = graph.get(vertex).get(i1);
                if (!mark[v]) {
                    mark[v] = true;
                    predecessor.get(i)[v] = vertex;
                    L.add(v);
                    distance.get(i)[v] = distance.get(i)[predecessor.get(i)[v]] + 1;
                }
            }
        }

    }


    public static int getDistance(int start, int end) {
        return (distance.get(start)[end]);
    }

    public static int getPredecessor(int start, int end) {
        return (predecessor.get(start)[end]);
    }

    private static void chooseNumOfEdges() {
        System.out.println("Please input the number of Edges:");
        chooseEdge = in.nextInt();
    }

    // Number of Vertices
    private static void chooseNumOfVertices() {
        in = new Scanner(System.in);
        System.out.println("Please input the number of Vertices:");
        limit = in.nextInt();

        // Read CSV
        List<String[]> content = readCsvFile();

        // Map each number to a city name
        cityMapping = new HashMap<>();
        for (int i = 0; i < limit; i++) {
            cityMapping.put(i, content.get(i)[0]);
        }

        // System.out.println(cityMapping);
    }

    // Read CSV file
    public static List<String[]> readCsvFile() {
        String csvFile = "./Lab 4/country.csv";
        BufferedReader br = null;
        ArrayList<String> names = new ArrayList<String>();
        List<String[]> content = new ArrayList<>();
        String cvsSplitBy = ",";

        try {
            String line = "";
            br = new BufferedReader(new FileReader(csvFile));
            while ((line = br.readLine()) != null) {
                content.add(line.split(cvsSplitBy));    
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        Random r = new Random();
        Collections.shuffle(content);
        return content;
    }


}