最短路径（航班问题）

本关任务：全国人民都盼望着疫情早日结束，到时可以多出去走动，到各个城市看一看，在“双十一”来临之际，规划一条到目的地的最便宜航线吧！

有 n 个城市通过一些航班连接。给你一个数组 flights ，其中 flights[i] = { start(i), end(i), price(i) } ，表示该航班都从城市 start(i) 开始，以价格 price(i) 抵达 end(i)。

现在给定所有的城市和航班，以及出发城市 src 和目的地 dst，你的任务是找到一条中转的路线，使得从 src 到 dst 的 总价格最便宜 ，并返回该价格。 题目保证了这样的路线一定存在。

import java.util.*; 

/**
 * 航班类Flight的定义，你可在代码中直接使用
 * public class Flight {
 *     int getId(); // 唯一标识符（除了唯一以外并无实质意义）
 *     String getStart();  // 起点名称，名称相同表示同一地点
 *     String getEnd();    // 终点名称，名称相同表示同一地点
 *     int getPrice();     // 从起点飞往终点的机票价格
 * }
 */

public class CheapestPriceSolution {
    
    /**
     * 计算最便宜的机票总价钱
     * @param n 表示最多总共有n个城市
     * @param flights 所有航班信息，以对象数组给出，每个Flight对象表示一个航班数据（起点-终点-价格）
     * @param src 起点的名称
     * @param dst 终点的名称
     * @return 搜索一条路径可以从起点转乘一直飞到终点，并且机票总价格最小，输出最小机票价格
     */
    public int findCheapestPrice(int n, Flight[] flights, String src, String dst) {
        // 请补充完整程序代码
        // TODO ...
        Map<String, Integer> cityToIdMap = new HashMap<>(); // 城市名称到标识符的映射表
        int id = 0;
        for (Flight flight : flights) {
            String start = flight.getStart();
            String end = flight.getEnd();
            if (!cityToIdMap.containsKey(start)) {
                cityToIdMap.put(start, id++);
            }
            if (!cityToIdMap.containsKey(end)) {
                cityToIdMap.put(end, id++);
            }
        }

        // 创建邻接矩阵用于存储航班信息
        int[][] graph = new int[n][n];
        for (int[] row : graph) {
            Arrays.fill(row, -1);
        }

        // 构建邻接矩阵
        for (Flight flight : flights) {
            int start = cityToIdMap.get(flight.getStart());
            int end = cityToIdMap.get(flight.getEnd());
            int price = flight.getPrice();
            graph[start][end] = price;
        }

        // 使用Dijkstra算法计算最短路径
        PriorityQueue<int[]> pq = new PriorityQueue<>((a, b) -> a[0] - b[0]);
        pq.offer(new int[] { 0, cityToIdMap.get(src), 0 }); // 价格、当前节点、经过的节点数
        Map<Integer, Integer> minCost = new HashMap<>();

        while (!pq.isEmpty()) {
            int[] curr = pq.poll();
            int price = curr[0];
            int city = curr[1];
            int stops = curr[2];

            if (city == cityToIdMap.get(dst)) {
                return price;
            }

            if (stops > n) {
                continue;
            }

            if (!minCost.containsKey(city) || price < minCost.get(city)) {
                minCost.put(city, price);

                for (int i = 0; i < n; i++) {
                    if (graph[city][i] != -1) {
                        int newPrice = price + graph[city][i];
                        pq.offer(new int[] { newPrice, i, stops + 1 });
                    }
                }
            }
        }

        return -1;
    }
}