寻找最便宜的航行旅途（最多经过k个中转站） · Cheapest Flights Within K Stops**

最新推荐文章于 2021-08-24 21:10:07 发布

原创最新推荐文章于 2021-08-24 21:10:07 发布 · 438 阅读

3 ·

CC 4.0 BY-SA版权

文章标签：

#算法

算法学习专栏收录该内容

1 篇文章

订阅专栏

该博客讨论了一道计算机科学题目，涉及图论和搜索算法。题目要求找到从源城市到目标城市，最多经过K次中转的最便宜航班路径。博主提出了使用贝尔曼-福特算法的变形来解决此问题，并提供了详细的代码实现。通过循环迭代和状态转移，最终找到最低成本的飞行路线。若无法找到符合条件的路径，则返回-1。

寻找最便宜的航行旅途（最多经过k个中转站） · Cheapest Flights Within K Stops

题目描述

有n个城市被一些航班所连接。每个航班 (u,v,w) 从城市u出发，到达城市v，价格为w。

给定城市数目 n，所有的航班flights。你的任务是找到从起点src到终点站dst的最便宜线路的价格，而旅途中最多只能中转K次。

如果没有找到合适的线路，返回 -1。

注意

1.总城市数 n 在 1-100 之间，每个城市被标号为 0 到 n-1。
2. 航线的总数在 0 到 n * (n - 1) / 2 之间每条航线会被以 [出发站，终点站，价格] 的形式展现。
3. 每条航线的价格都在 1-10000之间。
4. 中转站的总数限制范围为 0 到 n-1 之间。不会有重复或者自环航线出现

样例
样例 1:

输入: n = 3, flights = [[0,1,100],[1,2,100],[0,2,500]], src = 0,dst = 2, K = 0
输出: 500 样例 2:

输入:

n = 3, flights = [[0,1,100],[1,2,100],[0,2,500]], src = 0, dst = 2, K = 1
输出: 200

题目分析：
此题为搜索的变形题,多了一个K的限制，可以使用Bellman-Ford算法.
定义一个dfs数组代表每个城市的价格，fla 数组判断是否判断过该城市。
每次循环过一遍后用fill函数重置。
代码

class Solution {
public:
    /**
     * @param n: a integer
     * @param flights: a 2D array
     * @param src: a integer
     * @param dst: a integer
     * @param K: a integer
     * @return: return a integer
     */
    int findCheapestPrice(int n, vector<vector<int>> &flights, int src, int dst, int K) {
        // write your code here
        vector<int> dfs(n,1000000);
        int m=flights.size();
        vector<bool> fla(n,false);
        dfs[src]=0;
        for(int i=0;i<=K;i++)
        {
            for(int j=0;j<m;j++)
            {
                int u=flights[j][0];
                int w=flights[j][1];
                int v=flights[j][2];
                if(dfs[u]+v<dfs[w]&&!fla[u])
                {
                    dfs[w]=dfs[u]+v;
                    fla[w]=true;
                }
            }
            fill(fla.begin(),fla.end(),false);
        }
        if(dfs[dst]==1000000)return -1;
        else return dfs[dst];
        
    }
};