Skip to content

Commit bb4b52a

Browse files
yanglbmeyanglbme
authored
feat: add solutions for lc No.3651,3816 (#4982)
1 parent a2ceffa commit bb4b52a

14 files changed

Lines changed: 1213 additions & 14 deletions

File tree

‎solution/3600-3699/3651.Minimum Cost Path with Teleportations/README.md‎

Lines changed: 295 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -145,25 +145,317 @@ source: 第 163 场双周赛 Q4
145145
#### Python3
146146

147147
```python
148-
148+
class Solution:
149+
def minCost(self, grid: List[List[int]], k: int) -> int:
150+
m, n = len(grid), len(grid[0])
151+
f = [[[inf] * n for _ in range(m)] for _ in range(k + 1)]
152+
f[0][0][0] = 0
153+
for i in range(m):
154+
for j in range(n):
155+
if i:
156+
f[0][i][j] = min(f[0][i][j], f[0][i - 1][j] + grid[i][j])
157+
if j:
158+
f[0][i][j] = min(f[0][i][j], f[0][i][j - 1] + grid[i][j])
159+
g = defaultdict(list)
160+
for i, row in enumerate(grid):
161+
for j, x in enumerate(row):
162+
g[x].append((i, j))
163+
keys = sorted(g, reverse=True)
164+
for t in range(1, k + 1):
165+
mn = inf
166+
for key in keys:
167+
pos = g[key]
168+
for i, j in pos:
169+
mn = min(mn, f[t - 1][i][j])
170+
for i, j in pos:
171+
f[t][i][j] = mn
172+
for i in range(m):
173+
for j in range(n):
174+
if i:
175+
f[t][i][j] = min(f[t][i][j], f[t][i - 1][j] + grid[i][j])
176+
if j:
177+
f[t][i][j] = min(f[t][i][j], f[t][i][j - 1] + grid[i][j])
178+
return min(f[t][m - 1][n - 1] for t in range(k + 1))
149179
```
150180

151181
#### Java
152182

153183
```java
154-
184+
class Solution {
185+
public int minCost(int[][] grid, int k) {
186+
int m = grid.length, n = grid[0].length;
187+
int inf = Integer.MAX_VALUE / 2;
188+
189+
int[][][] f = new int[k + 1][m][n];
190+
for (int t = 0; t <= k; t++) {
191+
for (int i = 0; i < m; i++) {
192+
Arrays.fill(f[t][i], inf);
193+
}
194+
}
195+
196+
f[0][0][0] = 0;
197+
for (int i = 0; i < m; i++) {
198+
for (int j = 0; j < n; j++) {
199+
if (i > 0) {
200+
f[0][i][j] = Math.min(f[0][i][j], f[0][i - 1][j] + grid[i][j]);
201+
}
202+
if (j > 0) {
203+
f[0][i][j] = Math.min(f[0][i][j], f[0][i][j - 1] + grid[i][j]);
204+
}
205+
}
206+
}
207+
208+
Map<Integer, List<int[]>> g = new HashMap<>();
209+
for (int i = 0; i < m; i++) {
210+
for (int j = 0; j < n; j++) {
211+
int x = grid[i][j];
212+
g.computeIfAbsent(x, z -> new ArrayList<>()).add(new int[] {i, j});
213+
}
214+
}
215+
216+
List<Integer> keys = new ArrayList<>(g.keySet());
217+
keys.sort(Collections.reverseOrder());
218+
219+
for (int t = 1; t <= k; t++) {
220+
int mn = inf;
221+
for (int key : keys) {
222+
List<int[]> pos = g.get(key);
223+
for (int[] p : pos) {
224+
mn = Math.min(mn, f[t - 1][p[0]][p[1]]);
225+
}
226+
for (int[] p : pos) {
227+
f[t][p[0]][p[1]] = mn;
228+
}
229+
}
230+
for (int i = 0; i < m; i++) {
231+
for (int j = 0; j < n; j++) {
232+
if (i > 0) {
233+
f[t][i][j] = Math.min(f[t][i][j], f[t][i - 1][j] + grid[i][j]);
234+
}
235+
if (j > 0) {
236+
f[t][i][j] = Math.min(f[t][i][j], f[t][i][j - 1] + grid[i][j]);
237+
}
238+
}
239+
}
240+
}
241+
242+
int ans = inf;
243+
for (int t = 0; t <= k; t++) {
244+
ans = Math.min(ans, f[t][m - 1][n - 1]);
245+
}
246+
return ans;
247+
}
248+
}
155249
```
156250

157251
#### C++
158252

159253
```cpp
160-
254+
class Solution {
255+
public:
256+
int minCost(vector<vector<int>>& grid, int k) {
257+
int m = grid.size(), n = grid[0].size();
258+
int inf = INT_MAX / 2;
259+
260+
vector<vector<vector<int>>> f(k + 1, vector<vector<int>>(m, vector<int>(n, inf)));
261+
262+
f[0][0][0] = 0;
263+
for (int i = 0; i < m; i++) {
264+
for (int j = 0; j < n; j++) {
265+
if (i > 0) {
266+
f[0][i][j] = min(f[0][i][j], f[0][i - 1][j] + grid[i][j]);
267+
}
268+
if (j > 0) {
269+
f[0][i][j] = min(f[0][i][j], f[0][i][j - 1] + grid[i][j]);
270+
}
271+
}
272+
}
273+
274+
unordered_map<int, vector<pair<int, int>>> g;
275+
for (int i = 0; i < m; i++) {
276+
for (int j = 0; j < n; j++) {
277+
int x = grid[i][j];
278+
g[x].push_back({i, j});
279+
}
280+
}
281+
282+
vector<int> keys;
283+
keys.reserve(g.size());
284+
for (auto& e : g) {
285+
keys.push_back(e.first);
286+
}
287+
sort(keys.begin(), keys.end(), greater<int>());
288+
289+
for (int t = 1; t <= k; t++) {
290+
int mn = inf;
291+
for (int key : keys) {
292+
auto& pos = g[key];
293+
for (auto& p : pos) {
294+
mn = min(mn, f[t - 1][p.first][p.second]);
295+
}
296+
for (auto& p : pos) {
297+
f[t][p.first][p.second] = mn;
298+
}
299+
}
300+
for (int i = 0; i < m; i++) {
301+
for (int j = 0; j < n; j++) {
302+
if (i > 0) {
303+
f[t][i][j] = min(f[t][i][j], f[t][i - 1][j] + grid[i][j]);
304+
}
305+
if (j > 0) {
306+
f[t][i][j] = min(f[t][i][j], f[t][i][j - 1] + grid[i][j]);
307+
}
308+
}
309+
}
310+
}
311+
312+
int ans = inf;
313+
for (int t = 0; t <= k; t++) {
314+
ans = min(ans, f[t][m - 1][n - 1]);
315+
}
316+
return ans;
317+
}
318+
};
161319
```
162320

163321
#### Go
164322

165323
```go
324+
func minCost(grid [][]int, k int) int {
325+
m, n := len(grid), len(grid[0])
326+
inf := int(^uint(0)>>1) / 4
327+
328+
f := make([][][]int, k+1)
329+
for t := 0; t <= k; t++ {
330+
f[t] = make([][]int, m)
331+
for i := 0; i < m; i++ {
332+
f[t][i] = make([]int, n)
333+
for j := 0; j < n; j++ {
334+
f[t][i][j] = inf
335+
}
336+
}
337+
}
338+
339+
f[0][0][0] = 0
340+
for i := 0; i < m; i++ {
341+
for j := 0; j < n; j++ {
342+
if i > 0 {
343+
f[0][i][j] = min(f[0][i][j], f[0][i-1][j]+grid[i][j])
344+
}
345+
if j > 0 {
346+
f[0][i][j] = min(f[0][i][j], f[0][i][j-1]+grid[i][j])
347+
}
348+
}
349+
}
350+
351+
g := make(map[int][][]int)
352+
for i := 0; i < m; i++ {
353+
for j := 0; j < n; j++ {
354+
x := grid[i][j]
355+
g[x] = append(g[x], []int{i, j})
356+
}
357+
}
358+
359+
keys := make([]int, 0, len(g))
360+
for key := range g {
361+
keys = append(keys, key)
362+
}
363+
sort.Sort(sort.Reverse(sort.IntSlice(keys)))
364+
365+
for t := 1; t <= k; t++ {
366+
mn := inf
367+
for _, key := range keys {
368+
pos := g[key]
369+
for _, p := range pos {
370+
mn = min(mn, f[t-1][p[0]][p[1]])
371+
}
372+
for _, p := range pos {
373+
f[t][p[0]][p[1]] = mn
374+
}
375+
}
376+
for i := 0; i < m; i++ {
377+
for j := 0; j < n; j++ {
378+
if i > 0 {
379+
f[t][i][j] = min(f[t][i][j], f[t][i-1][j]+grid[i][j])
380+
}
381+
if j > 0 {
382+
f[t][i][j] = min(f[t][i][j], f[t][i][j-1]+grid[i][j])
383+
}
384+
}
385+
}
386+
}
387+
388+
ans := inf
389+
for t := 0; t <= k; t++ {
390+
ans = min(ans, f[t][m-1][n-1])
391+
}
392+
return ans
393+
}
394+
```
166395

396+
#### TypeScript
397+
398+
```ts
399+
function minCost(grid: number[][], k: number): number {
400+
const [m, n] = [grid.length, grid[0].length];
401+
const INF = 1e18;
402+
403+
const f: number[][][] = Array.from({ length: k + 1 }, () =>
404+
Array.from({ length: m }, () => Array(n).fill(INF)),
405+
);
406+
407+
f[0][0][0] = 0;
408+
for (let i = 0; i < m; i++) {
409+
for (let j = 0; j < n; j++) {
410+
if (i > 0) f[0][i][j] = Math.min(f[0][i][j], f[0][i - 1][j] + grid[i][j]);
411+
if (j > 0) f[0][i][j] = Math.min(f[0][i][j], f[0][i][j - 1] + grid[i][j]);
412+
}
413+
}
414+
415+
const g = new Map<number, Array<[number, number]>>();
416+
for (let i = 0; i < m; i++) {
417+
for (let j = 0; j < n; j++) {
418+
const x = grid[i][j];
419+
if (!g.has(x)) {
420+
g.set(x, []);
421+
}
422+
g.get(x)!.push([i, j]);
423+
}
424+
}
425+
426+
const keys = Array.from(g.keys()).sort((a, b) => b - a);
427+
428+
for (let t = 1; t <= k; t++) {
429+
let mn = INF;
430+
431+
for (const key of keys) {
432+
const pos = g.get(key)!;
433+
for (const [x, y] of pos) {
434+
mn = Math.min(mn, f[t - 1][x][y]);
435+
}
436+
for (const [x, y] of pos) {
437+
f[t][x][y] = mn;
438+
}
439+
}
440+
441+
for (let i = 0; i < m; i++) {
442+
for (let j = 0; j < n; j++) {
443+
if (i > 0) {
444+
f[t][i][j] = Math.min(f[t][i][j], f[t][i - 1][j] + grid[i][j]);
445+
}
446+
if (j > 0) {
447+
f[t][i][j] = Math.min(f[t][i][j], f[t][i][j - 1] + grid[i][j]);
448+
}
449+
}
450+
}
451+
}
452+
453+
let ans = INF;
454+
for (let t = 0; t <= k; t++) {
455+
ans = Math.min(ans, f[t][m - 1][n - 1]);
456+
}
457+
return ans;
458+
}
167459
```
168460

169461
<!-- tabs:end -->

0 commit comments

Comments
 (0)