题目

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

现在给定所有的城市和航班，以及出发城市 src 和目的地 dst，你的任务是找到出一条最多经过 k 站中转的路线，使得从 src 到 dst 的 价格最便宜 ，并返回该价格。 如果不存在这样的路线，则输出 -1。

示例 1：

输入: 
n = 3, edges = [[0,1,100],[1,2,100],[0,2,500]]
src = 0, dst = 2, k = 1
输出: 200
解释: 
城市航班图如下
从城市 0 到城市 2 在 1 站中转以内的最便宜价格是 200，如图中红色所示。

示例 2：

输入: 
n = 3, edges = [[0,1,100],[1,2,100],[0,2,500]]
src = 0, dst = 2, k = 0
输出: 500
解释: 
城市航班图如下
从城市 0 到城市 2 在 0 站中转以内的最便宜价格是 500，如图中蓝色所示。

提示：

• 1 <= n <= 100
• 0 <= flights.length <= (n * (n - 1) / 2)
• flights[i].length == 3
• \(0 <= from_i, to_i < n\)
• \(from_i != to_i\)
• \(1 <= price_i <= 10^4\)
• 航班没有重复，且不存在自环
• 0 <= src, dst, k < n
• src != dst

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/cheapest-flights-within-k-stops
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

思路

动态规划题，题目中有两个维度的信息需要考虑，一个是城市之间的转移，另一个则是中转次数。用dp[t][i]表示经过t次航班到达城市i的最低费用，那么它应该是所有经过t-1次航班到达可以飞往城市i的城市j的最低费用中的最小值，转移方程为

最多经过k站中转，也就是说搭乘的航班最多是k + 1次，构造二维数组dp[k + 1][n]，初始化dp[0][src] = 0，其他值全为无穷大。根据题目给出的1 <= n <= 100和\(1 <= price_i <= 10^4\)，可以将无穷大值看作101×10000 + 1（总费用是不会超过这个值的）。然后t从0遍历到k + 1，根据flights数组更新dp数组。最后取第dst列的最小值。
时间复杂度O((m + n)k)，空间复杂度O(nk)。

代码

class Solution {
public:
    int findCheapestPrice(int n, vector<vector<int>>& flights, int src, int dst, int k) {
        static const int INF = 101*10000 + 1;
        vector<vector<int>> dp(k + 2, vector<int>(n, INF));
        dp[0][src] = 0;
        for(int t = 1; t <= k + 1; ++t)
        {
            for(const auto &flight : flights)
            {
                const int i = flight[0], j = flight[1], cost = flight[2];
                dp[t][j] = min(dp[t][j], dp[t - 1][i] + cost);
            }
        }
        int ans = INF;
        for(int t = 0; t <= k + 1; ++t)
        {
            ans = min(ans, dp[t][dst]);
        }
        return ans == INF ? -1 : ans;
    }
};

改进

用一维数组替代二维数组，因为更新第t行时，只用得到t-1行的信息。
空间复杂度O(k)。

代码

class Solution {
public:
    int findCheapestPrice(int n, vector<vector<int>>& flights, int src, int dst, int k) {
        static const int INF = 101*10000 + 1;
        vector<int> f(n, INF);
        f[src] = 0;
        int ans = INF;
        for(int t = 1; t <= k + 1; ++t)
        {
            vector<int> g{f.begin(), f.end()};
            for(const auto& flight : flights)
            {
                const int i = flight[0], j = flight[1], cost = flight[2];
                g[j] = min(g[j], f[i] + cost);
            }
            f = move(g);
            ans = min(ans, f[dst]);
        }

        return ans == INF ? -1 : ans;
    }
};