LeetCode #787. Cheapest Flights Within K Stops

最新推荐文章于 2022-11-23 09:48:30 发布

原创最新推荐文章于 2022-11-23 09:48:30 发布 · 169 阅读

0 ·

CC 4.0 BY-SA版权

LeetCode 专栏收录该内容

625 篇文章

订阅专栏

本文介绍了一个算法问题，即在给定的城市和航班信息下，如何找到从起点到终点的最便宜价格，且不超过k次中转。通过构建图并使用队列进行广度优先搜索，算法能够有效地解决这一问题。

题目描述：

There are n cities connected by m flights. Each fight starts from city u and arrives at v with a price w.

Now given all the cities and flights, together with starting city src and the destination dst, your task is to find the cheapest price from src to dst with up to k stops. If there is no such route, output -1.

Example 1:
Input: 
n = 3, edges = [[0,1,100],[1,2,100],[0,2,500]]
src = 0, dst = 2, k = 1
Output: 200
Explanation: 
The graph looks like this:


The cheapest price from city 0 to city 2 with at most 1 stop costs 200, as marked red in the picture.

Example 2:
Input: 
n = 3, edges = [[0,1,100],[1,2,100],[0,2,500]]
src = 0, dst = 2, k = 0
Output: 500
Explanation: 
The graph looks like this:


The cheapest price from city 0 to city 2 with at most 0 stop costs 500, as marked blue in the picture.

Note:

The number of nodes n will be in range [1, 100], with nodes labeled from 0 to n - 1.
The size of flights will be in range [0, n * (n - 1) / 2].
The format of each flight will be (src, dst, price).
The price of each flight will be in the range [1, 10000].
k is in the range of [0, n - 1].
There will not be any duplicated flights or self cycles.

class Solution {
public:
    int findCheapestPrice(int n, vector<vector<int>>& flights, int src, int dst, int K) {
        vector<vector<pair<int,int>>> graph(n);
        for(auto flight:flights)
            graph[flight[0]].push_back({flight[1],flight[2]});
        int result=INT_MAX;
        queue<pair<int,int>> q;
        // 记录节点到起点的距离不能用哈希表dist，距离更新可能会影响到之后的同层节点，即某一层中存在i，j两个点
        // 而且存在一条边i->j，那么遍历i的邻接点，就会更新dist[j]，从而影响之后遍历j的邻接点
        q.push({src,0});
        int count=1;
        while(!q.empty())
        {
            int n=q.size();
            for(int i=0;i<n;i++)
            {
                int u=q.front().first, dist=q.front().second;
                q.pop();
                for(auto p:graph[u])
                { // u为中间点，v可能为终点，所以访问u的时候已经更新了v的距离
                    int v=p.first, cost=p.second;
                    if(dist+cost>result) continue; //到达任意一点的距离已经超过到终点的距离
                    if(v==dst) result=min(result,dist+cost);
                    q.push({v,dist+cost});
                }
            }
            // 在当前层访问结束后count加一，因为后面一层的距离已经更新了
            count++;
            // 注意K为起点和终点的中间点个数，count为路径节点总数
            if(K==count-2) break;
        }
        if(result==INT_MAX) return -1;
        else return result;
    }
};