Location via proxy:   [ UP ]  
[Report a bug]   [Manage cookies]                
Skip to content

Commit 5ee2352

Browse files
yanglbmeyanglbme
authored
feat: add solutions to lc problem: No.1928 (doocs#3597)
No.1928.Minimum Cost to Reach Destination in Time
1 parent 3f1171f commit 5ee2352

File tree

7 files changed

+359
-8
lines changed

7 files changed

+359
-8
lines changed

‎solution/1900-1999/1928.Minimum Cost to Reach Destination in Time/README.md

Lines changed: 125 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -81,32 +81,153 @@ tags:
8181

8282
<!-- solution:start -->
8383

84-
### 方法一
84+
### 方法一：动态规划
85+
86+
我们定义 $f[i][j]$ 表示经过 $i$ 分钟，从城市 $0$ 到达城市 $j$ 的最小花费。初始时 $f[0][0] = \textit{passingFees}[0]$，其余的 $f[0][j] = +\infty$。
87+
88+
接下来，我们在 $[1, \textit{maxTime}]$ 的时间范围内，遍历所有的边，对于每一条边 $(x, y, t)$，如果 $t \leq i$，那么我们：
89+
90+
- 可以先经过 $i - t$ 分钟，从城市 $0$ 到达城市 $y$，然后再经过 $t$ 分钟，从城市 $y$ 到达城市 $x$，再加上到达城市 $x$ 的通行费，即 $f[i][x] = \min(f[i][x], f[i - t][y] + \textit{passingFees}[x])$；
91+
- 也可以先经过 $i - t$ 分钟，从城市 $0$ 到达城市 $x$，然后再经过 $t$ 分钟，从城市 $x$ 到达城市 $y$，再加上到达城市 $y$ 的通行费，即 $f[i][y] = \min(f[i][y], f[i - t][x] + \textit{passingFees}[y])$。
92+
93+
最终答案即为 $\min\{f[i][n - 1]\}$，其中 $i \in [0, \textit{maxTime}]$。如果答案为 $+\infty$，则返回 $-1$。
94+
95+
时间复杂度 $O(\textit{maxTime} \times (m + n))$，其中 $m$ 和 $n$ 分别是边的数量和城市的数量。空间复杂度 $O(\textit{maxTime} \times n)$。
8596

8697
<!-- tabs:start -->
8798

8899
#### Python3
89100

90101
```python
91-
102+
class Solution:
103+
def minCost(
104+
self, maxTime: int, edges: List[List[int]], passingFees: List[int]
105+
) -> int:
106+
m, n = maxTime, len(passingFees)
107+
f = [[inf] * n for _ in range(m + 1)]
108+
f[0][0] = passingFees[0]
109+
for i in range(1, m + 1):
110+
for x, y, t in edges:
111+
if t <= i:
112+
f[i][x] = min(f[i][x], f[i - t][y] + passingFees[x])
113+
f[i][y] = min(f[i][y], f[i - t][x] + passingFees[y])
114+
ans = min(f[i][n - 1] for i in range(m + 1))
115+
return ans if ans < inf else -1
92116
```
93117

94118
#### Java
95119

96120
```java
97-
121+
class Solution {
122+
public int minCost(int maxTime, int[][] edges, int[] passingFees) {
123+
int m = maxTime, n = passingFees.length;
124+
int[][] f = new int[m + 1][n];
125+
final int inf = 1 << 30;
126+
for (var g : f) {
127+
Arrays.fill(g, inf);
128+
}
129+
f[0][0] = passingFees[0];
130+
for (int i = 1; i <= m; ++i) {
131+
for (var e : edges) {
132+
int x = e[0], y = e[1], t = e[2];
133+
if (t <= i) {
134+
f[i][x] = Math.min(f[i][x], f[i - t][y] + passingFees[x]);
135+
f[i][y] = Math.min(f[i][y], f[i - t][x] + passingFees[y]);
136+
}
137+
}
138+
}
139+
int ans = inf;
140+
for (int i = 0; i <= m; ++i) {
141+
ans = Math.min(ans, f[i][n - 1]);
142+
}
143+
return ans == inf ? -1 : ans;
144+
}
145+
}
98146
```
99147

100148
#### C++
101149

102150
```cpp
103-
151+
class Solution {
152+
public:
153+
int minCost(int maxTime, vector<vector<int>>& edges, vector<int>& passingFees) {
154+
int m = maxTime, n = passingFees.size();
155+
const int inf = 1 << 30;
156+
vector<vector<int>> f(m + 1, vector<int>(n, inf));
157+
f[0][0] = passingFees[0];
158+
for (int i = 1; i <= m; ++i) {
159+
for (const auto& e : edges) {
160+
int x = e[0], y = e[1], t = e[2];
161+
if (t <= i) {
162+
f[i][x] = min(f[i][x], f[i - t][y] + passingFees[x]);
163+
f[i][y] = min(f[i][y], f[i - t][x] + passingFees[y]);
164+
}
165+
}
166+
}
167+
int ans = inf;
168+
for (int i = 1; i <= m; ++i) {
169+
ans = min(ans, f[i][n - 1]);
170+
}
171+
return ans == inf ? -1 : ans;
172+
}
173+
};
104174
```
105175
106176
#### Go
107177
108178
```go
179+
func minCost(maxTime int, edges [][]int, passingFees []int) int {
180+
m, n := maxTime, len(passingFees)
181+
f := make([][]int, m+1)
182+
const inf int = 1 << 30
183+
for i := range f {
184+
f[i] = make([]int, n)
185+
for j := range f[i] {
186+
f[i][j] = inf
187+
}
188+
}
189+
f[0][0] = passingFees[0]
190+
for i := 1; i <= m; i++ {
191+
for _, e := range edges {
192+
x, y, t := e[0], e[1], e[2]
193+
if t <= i {
194+
f[i][x] = min(f[i][x], f[i-t][y]+passingFees[x])
195+
f[i][y] = min(f[i][y], f[i-t][x]+passingFees[y])
196+
}
197+
}
198+
}
199+
ans := inf
200+
for i := 1; i <= m; i++ {
201+
ans = min(ans, f[i][n-1])
202+
}
203+
if ans == inf {
204+
return -1
205+
}
206+
return ans
207+
}
208+
```
109209

210+
#### TypeScript
211+
212+
```ts
213+
function minCost(maxTime: number, edges: number[][], passingFees: number[]): number {
214+
const [m, n] = [maxTime, passingFees.length];
215+
const f: number[][] = Array.from({ length: m + 1 }, () => Array(n).fill(Infinity));
216+
f[0][0] = passingFees[0];
217+
for (let i = 1; i <= m; ++i) {
218+
for (const [x, y, t] of edges) {
219+
if (t <= i) {
220+
f[i][x] = Math.min(f[i][x], f[i - t][y] + passingFees[x]);
221+
f[i][y] = Math.min(f[i][y], f[i - t][x] + passingFees[y]);
222+
}
223+
}
224+
}
225+
let ans = Infinity;
226+
for (let i = 1; i <= m; ++i) {
227+
ans = Math.min(ans, f[i][n - 1]);
228+
}
229+
return ans === Infinity ? -1 : ans;
230+
}
110231
```
111232

112233
<!-- tabs:end -->

‎solution/1900-1999/1928.Minimum Cost to Reach Destination in Time/README_EN.md

Lines changed: 125 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -79,32 +79,153 @@ You cannot take path 0 -&gt; 1 -&gt; 2 -&gt; 5 since it would take too long.
7979

8080
<!-- solution:start -->
8181

82-
### Solution 1
82+
### Solution 1: Dynamic Programming
83+
84+
We define $f[i][j]$ to represent the minimum cost to reach city $j$ from city $0$ after $i$ minutes. Initially, $f[0][0] = \textit{passingFees}[0]$, and the rest $f[0][j] = +\infty$.
85+
86+
Next, within the time range $[1, \textit{maxTime}]$, we traverse all edges. For each edge $(x, y, t)$, if $t \leq i$, then we:
87+
88+
- Can first spend $i - t$ minutes to reach city $y$ from city $0$, then spend $t$ minutes to reach city $x$ from city $y$, and add the passing fee to reach city $x$, i.e., $f[i][x] = \min(f[i][x], f[i - t][y] + \textit{passingFees}[x])$;
89+
- Can also first spend $i - t$ minutes to reach city $x$ from city $0$, then spend $t$ minutes to reach city $y$ from city $x$, and add the passing fee to reach city $y$, i.e., $f[i][y] = \min(f[i][y], f[i - t][x] + \textit{passingFees}[y])$.
90+
91+
The final answer is $\min\{f[i][n - 1]\}$, where $i \in [0, \textit{maxTime}]$. If the answer is $+\infty$, return $-1$.
92+
93+
The time complexity is $O(\textit{maxTime} \times (m + n))$, where $m$ and $n$ are the number of edges and cities, respectively. The space complexity is $O(\textit{maxTime} \times n)$.
8394

8495
<!-- tabs:start -->
8596

8697
#### Python3
8798

8899
```python
89-
100+
class Solution:
101+
def minCost(
102+
self, maxTime: int, edges: List[List[int]], passingFees: List[int]
103+
) -> int:
104+
m, n = maxTime, len(passingFees)
105+
f = [[inf] * n for _ in range(m + 1)]
106+
f[0][0] = passingFees[0]
107+
for i in range(1, m + 1):
108+
for x, y, t in edges:
109+
if t <= i:
110+
f[i][x] = min(f[i][x], f[i - t][y] + passingFees[x])
111+
f[i][y] = min(f[i][y], f[i - t][x] + passingFees[y])
112+
ans = min(f[i][n - 1] for i in range(m + 1))
113+
return ans if ans < inf else -1
90114
```
91115

92116
#### Java
93117

94118
```java
95-
119+
class Solution {
120+
public int minCost(int maxTime, int[][] edges, int[] passingFees) {
121+
int m = maxTime, n = passingFees.length;
122+
int[][] f = new int[m + 1][n];
123+
final int inf = 1 << 30;
124+
for (var g : f) {
125+
Arrays.fill(g, inf);
126+
}
127+
f[0][0] = passingFees[0];
128+
for (int i = 1; i <= m; ++i) {
129+
for (var e : edges) {
130+
int x = e[0], y = e[1], t = e[2];
131+
if (t <= i) {
132+
f[i][x] = Math.min(f[i][x], f[i - t][y] + passingFees[x]);
133+
f[i][y] = Math.min(f[i][y], f[i - t][x] + passingFees[y]);
134+
}
135+
}
136+
}
137+
int ans = inf;
138+
for (int i = 0; i <= m; ++i) {
139+
ans = Math.min(ans, f[i][n - 1]);
140+
}
141+
return ans == inf ? -1 : ans;
142+
}
143+
}
96144
```
97145

98146
#### C++
99147

100148
```cpp
101-
149+
class Solution {
150+
public:
151+
int minCost(int maxTime, vector<vector<int>>& edges, vector<int>& passingFees) {
152+
int m = maxTime, n = passingFees.size();
153+
const int inf = 1 << 30;
154+
vector<vector<int>> f(m + 1, vector<int>(n, inf));
155+
f[0][0] = passingFees[0];
156+
for (int i = 1; i <= m; ++i) {
157+
for (const auto& e : edges) {
158+
int x = e[0], y = e[1], t = e[2];
159+
if (t <= i) {
160+
f[i][x] = min(f[i][x], f[i - t][y] + passingFees[x]);
161+
f[i][y] = min(f[i][y], f[i - t][x] + passingFees[y]);
162+
}
163+
}
164+
}
165+
int ans = inf;
166+
for (int i = 1; i <= m; ++i) {
167+
ans = min(ans, f[i][n - 1]);
168+
}
169+
return ans == inf ? -1 : ans;
170+
}
171+
};
102172
```
103173
104174
#### Go
105175
106176
```go
177+
func minCost(maxTime int, edges [][]int, passingFees []int) int {
178+
m, n := maxTime, len(passingFees)
179+
f := make([][]int, m+1)
180+
const inf int = 1 << 30
181+
for i := range f {
182+
f[i] = make([]int, n)
183+
for j := range f[i] {
184+
f[i][j] = inf
185+
}
186+
}
187+
f[0][0] = passingFees[0]
188+
for i := 1; i <= m; i++ {
189+
for _, e := range edges {
190+
x, y, t := e[0], e[1], e[2]
191+
if t <= i {
192+
f[i][x] = min(f[i][x], f[i-t][y]+passingFees[x])
193+
f[i][y] = min(f[i][y], f[i-t][x]+passingFees[y])
194+
}
195+
}
196+
}
197+
ans := inf
198+
for i := 1; i <= m; i++ {
199+
ans = min(ans, f[i][n-1])
200+
}
201+
if ans == inf {
202+
return -1
203+
}
204+
return ans
205+
}
206+
```
107207

208+
#### TypeScript
209+
210+
```ts
211+
function minCost(maxTime: number, edges: number[][], passingFees: number[]): number {
212+
const [m, n] = [maxTime, passingFees.length];
213+
const f: number[][] = Array.from({ length: m + 1 }, () => Array(n).fill(Infinity));
214+
f[0][0] = passingFees[0];
215+
for (let i = 1; i <= m; ++i) {
216+
for (const [x, y, t] of edges) {
217+
if (t <= i) {
218+
f[i][x] = Math.min(f[i][x], f[i - t][y] + passingFees[x]);
219+
f[i][y] = Math.min(f[i][y], f[i - t][x] + passingFees[y]);
220+
}
221+
}
222+
}
223+
let ans = Infinity;
224+
for (let i = 1; i <= m; ++i) {
225+
ans = Math.min(ans, f[i][n - 1]);
226+
}
227+
return ans === Infinity ? -1 : ans;
228+
}
108229
```
109230

110231
<!-- tabs:end -->

‎solution/1900-1999/1928.Minimum Cost to Reach Destination in Time/Solution.cpp

Lines changed: 23 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,23 @@
1+
class Solution {
2+
public:
3+
int minCost(int maxTime, vector<vector<int>>& edges, vector<int>& passingFees) {
4+
int m = maxTime, n = passingFees.size();
5+
const int inf = 1 << 30;
6+
vector<vector<int>> f(m + 1, vector<int>(n, inf));
7+
f[0][0] = passingFees[0];
8+
for (int i = 1; i <= m; ++i) {
9+
for (const auto& e : edges) {
10+
int x = e[0], y = e[1], t = e[2];
11+
if (t <= i) {
12+
f[i][x] = min(f[i][x], f[i - t][y] + passingFees[x]);
13+
f[i][y] = min(f[i][y], f[i - t][x] + passingFees[y]);
14+
}
15+
}
16+
}
17+
int ans = inf;
18+
for (int i = 1; i <= m; ++i) {
19+
ans = min(ans, f[i][n - 1]);
20+
}
21+
return ans == inf ? -1 : ans;
22+
}
23+
};

‎solution/1900-1999/1928.Minimum Cost to Reach Destination in Time/Solution.go

Lines changed: 29 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,29 @@
1+
func minCost(maxTime int, edges [][]int, passingFees []int) int {
2+
m, n := maxTime, len(passingFees)
3+
f := make([][]int, m+1)
4+
const inf int = 1 << 30
5+
for i := range f {
6+
f[i] = make([]int, n)
7+
for j := range f[i] {
8+
f[i][j] = inf
9+
}
10+
}
11+
f[0][0] = passingFees[0]
12+
for i := 1; i <= m; i++ {
13+
for _, e := range edges {
14+
x, y, t := e[0], e[1], e[2]
15+
if t <= i {
16+
f[i][x] = min(f[i][x], f[i-t][y]+passingFees[x])
17+
f[i][y] = min(f[i][y], f[i-t][x]+passingFees[y])
18+
}
19+
}
20+
}
21+
ans := inf
22+
for i := 1; i <= m; i++ {
23+
ans = min(ans, f[i][n-1])
24+
}
25+
if ans == inf {
26+
return -1
27+
}
28+
return ans
29+
}

‎solution/1900-1999/1928.Minimum Cost to Reach Destination in Time/Solution.java

Lines changed: 25 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,25 @@
1+
class Solution {
2+
public int minCost(int maxTime, int[][] edges, int[] passingFees) {
3+
int m = maxTime, n = passingFees.length;
4+
int[][] f = new int[m + 1][n];
5+
final int inf = 1 << 30;
6+
for (var g : f) {
7+
Arrays.fill(g, inf);
8+
}
9+
f[0][0] = passingFees[0];
10+
for (int i = 1; i <= m; ++i) {
11+
for (var e : edges) {
12+
int x = e[0], y = e[1], t = e[2];
13+
if (t <= i) {
14+
f[i][x] = Math.min(f[i][x], f[i - t][y] + passingFees[x]);
15+
f[i][y] = Math.min(f[i][y], f[i - t][x] + passingFees[y]);
16+
}
17+
}
18+
}
19+
int ans = inf;
20+
for (int i = 0; i <= m; ++i) {
21+
ans = Math.min(ans, f[i][n - 1]);
22+
}
23+
return ans == inf ? -1 : ans;
24+
}
25+
}

0 commit comments

Comments
 (0)