Печать кратчайшего пути в двумерном массиве

Я использовал алгоритм дигестры для вычисления кратчайшего пути. Вы можете попробовать это

    Set<String> addressSet = your AddressSet;

       int[][] adjacencyMatrix = prepareAdjacencyMatrix(employee, addressSet);

       return new CalculateShortestPath(adjacencyMatrix.length - 1)
                        .calculate(adjacencyMatrix, 1);


      private int[][] prepareAdjacencyMatrix(Employee employee,
                                                   Set<String> addressSet) {
                List<String> addressList = new ArrayList<>();
                addressList.addAll(addressSet);

                int l = addressSet.size();
                int[][] adjacencyMatrix = new int[l + 1][l + 1];

                for (int i = 1; i <= l; i++) {
                    for (int j = 1; j <= l; j++) {
                        if (i == j) {
                            adjacencyMatrix[i][j] = Integer.MAX_VALUE;
                        } else {
                            String key = getAddressKey(addressList.get(i - 1), addressList.get(j - 1), employee.getTransport());
                            String reverseKey = getAddressKey(addressList.get(j - 1), addressList.get(i - 1),
                                    employee.getTransport());

                            if (distanceMatrix.containsKey(key)) {
                                adjacencyMatrix[i][j] = 0;

                            } else if (distanceMatrix.containsKey(reverseKey)) {
                                adjacencyMatrix[i][j] = 0;
                            }
                        }
                    }
                }
                return adjacencyMatrix;
            }

private String getAddressKey(String sourceCity,
                                 String destinationCity, MeansOfTransport transport) {
        return sourceCity + "-" + destinationCity + "-" +
                (nonNull(transport) ? transport.getName() : MeansOfTransport.DRIVING.getName());
    }

            public class CalculateShortestPath {
            private int distances[];
            private Set<Integer> settled;
            private Set<Integer> unsettled;
            private int number_of_nodes;
            private int adjacencyMatrix[][];

            public CalculateShortestPath(int number_of_nodes) {
                this.number_of_nodes = number_of_nodes;
                distances = new int[number_of_nodes + 1];
                settled = new HashSet<>();
                unsettled = new HashSet<>();
                adjacencyMatrix = new int[number_of_nodes + 1][number_of_nodes + 1];
            }

            private void dijkstra_algorithm(int adjacency_matrix[][], int source) {
                int evaluationNode;
                for (int i = 1; i <= number_of_nodes; i++) {
                    System.arraycopy(adjacency_matrix[i], 1, adjacencyMatrix[i], 1, number_of_nodes);
                }

                for (int i = 1; i <= number_of_nodes; i++) {
                    distances[i] = Integer.MAX_VALUE;
                }

                unsettled.add(source);
                distances[source] = 0;
                while (!unsettled.isEmpty()) {
                    evaluationNode = getNodeWithMinimumDistanceFromUnsettled();
                    unsettled.remove(evaluationNode);
                    settled.add(evaluationNode);
                    evaluateNeighbours(evaluationNode);
                }
            }

            private int getNodeWithMinimumDistanceFromUnsettled() {
                Iterator<Integer> iterator = unsettled.iterator();
                int node = iterator.next();
                int min = distances[node];
                for (int i = 1; i <= distances.length; i++) {
                    if (unsettled.contains(i)) {
                        if (distances[i] <= min) {
                            min = distances[i];
                            node = i;
                        }
                    }
                }
                return node;
            }

            private void evaluateNeighbours(int evaluationNode) {
                int edgeDistance = -1;
                int newDistance = -1;

                for (int destinationNode = 1; destinationNode <= number_of_nodes; destinationNode++) {
                    if (!settled.contains(destinationNode)) {
                        if (adjacencyMatrix[evaluationNode][destinationNode] != Integer.MAX_VALUE) {
                            edgeDistance = adjacencyMatrix[evaluationNode][destinationNode];
                            newDistance = distances[evaluationNode] + edgeDistance;
                            if (newDistance < distances[destinationNode]) {
                                distances[destinationNode] = newDistance;
                            }
                            unsettled.add(destinationNode);
                        }
                    }
                }
            }

            public int calculate(int[][] adjacency_matrix, int source) {
                int shortestPath = Integer.MAX_VALUE;

                try {
                    dijkstra_algorithm(adjacency_matrix, source);

                    for (int i = 1; i <= distances.length - 1; i++) {
                        if (distances[i] > 0 && distances[i] < shortestPath) {
                            shortestPath = distances[i];
                        }

                    }
                } catch (InputMismatchException inputMismatch) {
                    System.out.println("Wrong Input Format");
                }

                return shortestPath;
            }
        }