Skip to content

Commit 3b80455

Browse files
yanglbmeyanglbme
committed
feat: add solutions to lc problem: No.0787
No.0787.Cheapest Flights Within K Stop
1 parent ce93742 commit 3b80455

File tree

22 files changed

+1373
-26
lines changed

22 files changed

+1373
-26
lines changed

‎solution/0700-0799/0787.Cheapest Flights Within K Stops/README.md

+152-1
Original file line numberDiff line numberDiff line change
@@ -55,22 +55,173 @@ src = 0, dst = 2, k = 0
5555

5656
<!-- 这里可写通用的实现逻辑 -->
5757

58+
DFS + 记忆化搜索。
59+
5860
<!-- tabs:start -->
5961

6062
### **Python3**
6163

6264
<!-- 这里可写当前语言的特殊实现逻辑 -->
6365

6466
```python
65-
67+
from functools import lru_cache
68+
69+
70+
class Solution:
71+
def findCheapestPrice(self, n: int, flights: List[List[int]], src: int, dst: int, k: int) -> int:
72+
@lru_cache(None)
73+
def dfs(u, k):
74+
if u == dst:
75+
return 0
76+
if k <= 0:
77+
return float('inf')
78+
k -= 1
79+
ans = float('inf')
80+
for v, p in g[u]:
81+
ans = min(ans, dfs(v, k) + p)
82+
return ans
83+
84+
g = defaultdict(list)
85+
for u, v, p in flights:
86+
g[u].append((v, p))
87+
ans = dfs(src, k + 1)
88+
return -1 if ans >= float('inf') else ans
6689
```
6790

6891
### **Java**
6992

7093
<!-- 这里可写当前语言的特殊实现逻辑 -->
7194

7295
```java
96+
class Solution {
97+
private int[][] memo;
98+
private int[][] g;
99+
private int dst;
100+
private static final int INF = (int) 1e6;
101+
102+
public int findCheapestPrice(int n, int[][] flights, int src, int dst, int k) {
103+
n += 10;
104+
memo = new int[n][n];
105+
for (int i = 0; i < n; ++i) {
106+
Arrays.fill(memo[i], -1);
107+
}
108+
g = new int[n][n];
109+
for (int[] e : flights) {
110+
g[e[0]][e[1]] = e[2];
111+
}
112+
this.dst = dst;
113+
int ans = dfs(src, k + 1);
114+
return ans >= INF ? -1 : ans;
115+
}
116+
117+
private int dfs(int u, int k) {
118+
if (memo[u][k] != -1) {
119+
return memo[u][k];
120+
}
121+
if (u == dst) {
122+
return 0;
123+
}
124+
if (k <= 0) {
125+
return INF;
126+
}
127+
int ans = INF;
128+
for (int v = 0; v < g[u].length; ++v) {
129+
if (g[u][v] > 0) {
130+
ans = Math.min(ans, dfs(v, k - 1) + g[u][v]);
131+
}
132+
}
133+
memo[u][k] = ans;
134+
return ans;
135+
}
136+
}
137+
```
138+
139+
### **C++**
140+
141+
```cpp
142+
class Solution {
143+
public:
144+
vector<vector<int>> memo;
145+
vector<vector<int>> g;
146+
int dst;
147+
int inf = 1e6;
148+
149+
int findCheapestPrice(int n, vector<vector<int>>& flights, int src, int dst, int k) {
150+
n += 10;
151+
memo.resize(n, vector<int>(n, -1));
152+
g.resize(n, vector<int>(n));
153+
for (auto& e : flights) g[e[0]][e[1]] = e[2];
154+
this->dst = dst;
155+
int ans = dfs(src, k + 1);
156+
return ans >= inf ? -1 : ans;
157+
}
158+
159+
int dfs(int u, int k) {
160+
if (memo[u][k] != -1) return memo[u][k];
161+
if (u == dst) return 0;
162+
if (k <= 0) return inf;
163+
int ans = inf;
164+
for (int v = 0; v < g[u].size(); ++v)
165+
if (g[u][v] > 0)
166+
ans = min(ans, dfs(v, k - 1) + g[u][v]);
167+
memo[u][k] = ans;
168+
return memo[u][k];
169+
}
170+
};
171+
```
73172
173+
### **Go**
174+
175+
```go
176+
func findCheapestPrice(n int, flights [][]int, src int, dst int, k int) int {
177+
n += 10
178+
memo := make([][]int, n)
179+
g := make([][]int, n)
180+
for i := range memo {
181+
memo[i] = make([]int, n)
182+
g[i] = make([]int, n)
183+
for j := range memo[i] {
184+
memo[i][j] = -1
185+
}
186+
}
187+
188+
for _, e := range flights {
189+
g[e[0]][e[1]] = e[2]
190+
}
191+
inf := int(1e6)
192+
var dfs func(u, k int) int
193+
dfs = func(u, k int) int {
194+
if memo[u][k] != -1 {
195+
return memo[u][k]
196+
}
197+
if u == dst {
198+
return 0
199+
}
200+
if k <= 0 {
201+
return inf
202+
}
203+
ans := inf
204+
for v, p := range g[u] {
205+
if p > 0 {
206+
ans = min(ans, dfs(v, k-1)+p)
207+
}
208+
}
209+
memo[u][k] = ans
210+
return ans
211+
}
212+
ans := dfs(src, k+1)
213+
if ans >= inf {
214+
return -1
215+
}
216+
return ans
217+
}
218+
219+
func min(a, b int) int {
220+
if a < b {
221+
return a
222+
}
223+
return b
224+
}
74225
```
75226

76227
### **...**

‎solution/0700-0799/0787.Cheapest Flights Within K Stops/README_EN.md

+150-1
Original file line numberDiff line numberDiff line change
@@ -52,13 +52,162 @@ The cheapest price from city <code>0</code> to city <code>2</code> with at most
5252
### **Python3**
5353

5454
```python
55-
55+
from functools import lru_cache
56+
57+
58+
class Solution:
59+
def findCheapestPrice(self, n: int, flights: List[List[int]], src: int, dst: int, k: int) -> int:
60+
@lru_cache(None)
61+
def dfs(u, k):
62+
if u == dst:
63+
return 0
64+
if k <= 0:
65+
return float('inf')
66+
k -= 1
67+
ans = float('inf')
68+
for v, p in g[u]:
69+
ans = min(ans, dfs(v, k) + p)
70+
return ans
71+
72+
g = defaultdict(list)
73+
for u, v, p in flights:
74+
g[u].append((v, p))
75+
ans = dfs(src, k + 1)
76+
return -1 if ans >= float('inf') else ans
5677
```
5778

5879
### **Java**
5980

6081
```java
82+
class Solution {
83+
private int[][] memo;
84+
private int[][] g;
85+
private int dst;
86+
private static final int INF = (int) 1e6;
87+
88+
public int findCheapestPrice(int n, int[][] flights, int src, int dst, int k) {
89+
n += 10;
90+
memo = new int[n][n];
91+
for (int i = 0; i < n; ++i) {
92+
Arrays.fill(memo[i], -1);
93+
}
94+
g = new int[n][n];
95+
for (int[] e : flights) {
96+
g[e[0]][e[1]] = e[2];
97+
}
98+
this.dst = dst;
99+
int ans = dfs(src, k + 1);
100+
return ans >= INF ? -1 : ans;
101+
}
102+
103+
private int dfs(int u, int k) {
104+
if (memo[u][k] != -1) {
105+
return memo[u][k];
106+
}
107+
if (u == dst) {
108+
return 0;
109+
}
110+
if (k <= 0) {
111+
return INF;
112+
}
113+
int ans = INF;
114+
for (int v = 0; v < g[u].length; ++v) {
115+
if (g[u][v] > 0) {
116+
ans = Math.min(ans, dfs(v, k - 1) + g[u][v]);
117+
}
118+
}
119+
memo[u][k] = ans;
120+
return ans;
121+
}
122+
}
123+
```
124+
125+
### **C++**
126+
127+
```cpp
128+
class Solution {
129+
public:
130+
vector<vector<int>> memo;
131+
vector<vector<int>> g;
132+
int dst;
133+
int inf = 1e6;
134+
135+
int findCheapestPrice(int n, vector<vector<int>>& flights, int src, int dst, int k) {
136+
n += 10;
137+
memo.resize(n, vector<int>(n, -1));
138+
g.resize(n, vector<int>(n));
139+
for (auto& e : flights) g[e[0]][e[1]] = e[2];
140+
this->dst = dst;
141+
int ans = dfs(src, k + 1);
142+
return ans >= inf ? -1 : ans;
143+
}
144+
145+
int dfs(int u, int k) {
146+
if (memo[u][k] != -1) return memo[u][k];
147+
if (u == dst) return 0;
148+
if (k <= 0) return inf;
149+
int ans = inf;
150+
for (int v = 0; v < g[u].size(); ++v)
151+
if (g[u][v] > 0)
152+
ans = min(ans, dfs(v, k - 1) + g[u][v]);
153+
memo[u][k] = ans;
154+
return memo[u][k];
155+
}
156+
};
157+
```
61158
159+
### **Go**
160+
161+
```go
162+
func findCheapestPrice(n int, flights [][]int, src int, dst int, k int) int {
163+
n += 10
164+
memo := make([][]int, n)
165+
g := make([][]int, n)
166+
for i := range memo {
167+
memo[i] = make([]int, n)
168+
g[i] = make([]int, n)
169+
for j := range memo[i] {
170+
memo[i][j] = -1
171+
}
172+
}
173+
174+
for _, e := range flights {
175+
g[e[0]][e[1]] = e[2]
176+
}
177+
inf := int(1e6)
178+
var dfs func(u, k int) int
179+
dfs = func(u, k int) int {
180+
if memo[u][k] != -1 {
181+
return memo[u][k]
182+
}
183+
if u == dst {
184+
return 0
185+
}
186+
if k <= 0 {
187+
return inf
188+
}
189+
ans := inf
190+
for v, p := range g[u] {
191+
if p > 0 {
192+
ans = min(ans, dfs(v, k-1)+p)
193+
}
194+
}
195+
memo[u][k] = ans
196+
return ans
197+
}
198+
ans := dfs(src, k+1)
199+
if ans >= inf {
200+
return -1
201+
}
202+
return ans
203+
}
204+
205+
func min(a, b int) int {
206+
if a < b {
207+
return a
208+
}
209+
return b
210+
}
62211
```
63212

64213
### **...**

‎solution/0700-0799/0787.Cheapest Flights Within K Stops/Solution.cpp

+29
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,29 @@
1+
class Solution {
2+
public:
3+
vector<vector<int>> memo;
4+
vector<vector<int>> g;
5+
int dst;
6+
int inf = 1e6;
7+
8+
int findCheapestPrice(int n, vector<vector<int>>& flights, int src, int dst, int k) {
9+
n += 10;
10+
memo.resize(n, vector<int>(n, -1));
11+
g.resize(n, vector<int>(n));
12+
for (auto& e : flights) g[e[0]][e[1]] = e[2];
13+
this->dst = dst;
14+
int ans = dfs(src, k + 1);
15+
return ans >= inf ? -1 : ans;
16+
}
17+
18+
int dfs(int u, int k) {
19+
if (memo[u][k] != -1) return memo[u][k];
20+
if (u == dst) return 0;
21+
if (k <= 0) return inf;
22+
int ans = inf;
23+
for (int v = 0; v < g[u].size(); ++v)
24+
if (g[u][v] > 0)
25+
ans = min(ans, dfs(v, k - 1) + g[u][v]);
26+
memo[u][k] = ans;
27+
return memo[u][k];
28+
}
29+
};

0 commit comments

Comments
 (0)