import java.util.*;

class ShortestPathToWork {
    private static class Node implements Comparable<Node> {
        final String name;
        final int distance;

        public Node(String name, int distance) {
            this.name = name;
            this.distance = distance;
        }

        @Override
        public int compareTo(Node other) {
            return Integer.compare(this.distance, other.distance);
        }
    }

    private final Map<String, List<Node>> adjList = new HashMap<>();
    private final Map<String, Integer> distances = new HashMap<>();
    private final Map<String, String> previousNodes = new HashMap<>(); // 记录前驱节点

    public void addEdge(String from, String to, int distance) {
        adjList.computeIfAbsent(from, k -> new ArrayList<>()).add(new Node(to, distance));
    }

    public void dijkstra(String start) {
        PriorityQueue<Node> pq = new PriorityQueue<>();
        pq.add(new Node(start, 0));
        distances.put(start, 0);
        previousNodes.put(start, null); // 起点的前驱为 null

        while (!pq.isEmpty()) {
            Node current = pq.poll();
            String currentNode = current.name;

            if (adjList.containsKey(currentNode)) {
                for (Node neighbor : adjList.get(currentNode)) {
                    int newDist = distances.get(currentNode) + neighbor.distance;
                    if (!distances.containsKey(neighbor.name) || newDist < distances.get(neighbor.name)) {
                        distances.put(neighbor.name, newDist);
                        previousNodes.put(neighbor.name, currentNode); // 更新前驱节点
                        pq.add(new Node(neighbor.name, newDist));
                    }
                }
            }
        }
    }

    // 新增：计算从 start 到 end 的最短路径，并返回路径（节点列表）
    public List<String> getShortestPath(String start, String end) {
        dijkstra(start); // 重新计算最短路径（确保数据是最新的）
        List<String> path = new ArrayList<>();
        String current = end;

        // 回溯路径
        while (current != null) {
            path.add(current);
            current = previousNodes.get(current); // 获取前驱节点
        }

        Collections.reverse(path); // 反转路径，从起点到终点
        return path;
    }

    public void printShortestPath(String start, String end) {
        List<String> path = getShortestPath(start, end);
        System.out.println("Shortest path from " + start + " to " + end + ": " + String.join(" -> ", path));
        System.out.println("Total distance: " + distances.get(end)); // distances 已经在 dijkstra 中计算过
    }

    public static void main(String[] args) {
        ShortestPathToWork graph = new ShortestPathToWork();

        // 根据新图添加边和权重
        graph.addEdge("A", "E", 10);
        graph.addEdge("A", "H", 5);
        graph.addEdge("E", "C", 15);
        graph.addEdge("E", "O", 14);
        graph.addEdge("O", "E", 14);
        graph.addEdge("H", "O", 18);
        graph.addEdge("O", "H", 18);
        graph.addEdge("H", "D", 4);
        graph.addEdge("O", "G", 8);
        graph.addEdge("G", "O", 8);
        graph.addEdge("O", "F", 6);
        graph.addEdge("F", "O", 6);
        graph.addEdge("C", "G", 5);
        graph.addEdge("D", "F", 3);
        graph.addEdge("F", "B", 20);
        graph.addEdge("G", "B", 5);

        // 计算并打印从 A 到 B 的最短路径
        graph.printShortestPath("A", "B");
    }
}

Shortest path from A to B: A -> H -> D -> F -> O -> G -> B
Total distance: 31