[Leetcode] 787 Cheapest Flights Within K Stops

标签：mos   hose   price   忘记   inpu   top   cycle   ted   获取   

原题链接

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.

题目理解：这道题给的是一个direct weight graph，中间可能有环。给定一个起点和一个终点，求在k个vertices中经过的path weight和最少是多少。

这道题有几个关键的点需要注意：

1. 可能有环：需要一个unordered_set来记录所有已经访问过的vertices

2. 一个起点一个终点：是一个典型的search问题，那么有三种思路：DFS, BFS, DP

3. 返回的是一个最小的weight，而不是path，所以一定可以优化成一个DP的问题

那么现在就从最简单的BFS的方法开始：

解法1:

使用BFS的话首先要做图，从CLRS上可以看到一共有两种制图方法：

 1 class Solution {
 2     public:
 3     int findCheapestPrice(int n, vector<vector<int>>& flights, int src, int dst, int K) {
 4         int res = 1e9, cnt = 0;
 5         unordered_map<int, vector<vector<int>>> m;
 6         queue<vector<int>> q{{{src, 0}}};
 7         for (auto flight : flights) {
 8             m[flight[0]].push_back({flight[1], flight[2]}); // key: src,  value: {dst, weight}
 9         }
10         while (!q.empty()) {
11             for (int i = q.size(); i > 0; --i) {
12                 auto t = q.front(); 
13                 q.pop();
14                 if (t[0] == dst) res = min(res, t[1]); // now you reach the dst, you can check the weight
15                 for (auto a : m[t[0]]) {
16                     if (t[1] + a[1] > res) // skip if the cost is already more than the previous minimal cost
17                         continue;
18                     q.push({a[0], t[1] + a[1]}); // we now have a new path from old src to the neighour
19                 }
20             }
21             if (cnt++ > K) // now we are going to expand to next level
22                 break;
23         }
24         return (res == 1e9) ? -1 : res;
25     }
26 };

解法2:

使用DP的思想首先要找到状态表示方程，如果在任意一个vertice，那么我们有三个状态：

1. 当前的vertice

2. 当前的总weight (从src）

3. 当前经过的所有节点数

我们要求的是最小的weight，所以我们把dp设置成dp[节点数][当前节点]=最小weight（注意，这里是最小，否则没有意义）

那么如果想要知道从src到dst的总最小cost，用dp方程表示便是dp[k][dst]。如何从上一个状态来获取现在的最小值呢？

我们先看上一个状态有哪些可能：假设当前的节点数是i, 当前的节点是j

1. dp[i - 1][all the previous neighbour] + the weight from previous neighbour to j

2. dp[i][j] (just skip last neighbour, and fly directly from src to j)

为了得到所有的neighbour，需要在做一个关于当前neighbour的loop，所以一共有两个loop

这样做的的时间复杂度实际上也是O(k * n)

 1 #define vvi vector<vector<int>>
 2 #define vi vector<int>
 3 
 4 class Solution {
 5 public:
 6     int findCheapestPrice(int n, vvi& flights, int src, int dst, int K) {
 7         vvi dp(K + 2, vi(n, 1e9)); // all init as unreachable
 8         dp[0][src] = 0;
 9         for (int i = 1; i < K + 2; ++i) {
10             dp[i][src] = 0; // src to src with whatever stops doesn‘t cost anything
11             for (vi f : flights) // src, dst, weight
12                 dp[i][f[1]] = min(dp[i][f[1]], dp[i - 1][f[0]] + f[2]);
13         }
14         return dp[K + 1][dst] == 1e9 ? -1 : dp[K + 1][dst];
15     }
16 };

[Leetcode] 787 Cheapest Flights Within K Stops

标签：mos   hose   price   忘记   inpu   top   cycle   ted   获取   

原文地址：https://www.cnblogs.com/goldenticket/p/11915221.html