feat: add Rust solution for lc No.3651 (#4999)

Author: yanglbme

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

@@ -138,7 +138,41 @@ source: 第 163 场双周赛 Q4
 
 <!-- solution:start -->
 
-### 方法一
+### 方法一：动态规划
+
+我们定义 $f[t][i][j]$ 表示使用了 $t$ 次传送到达单元格 $(i, j)$ 的最小成本，初始时 $f[0][0][0] = 0$，其余状态均为无穷大。
+
+接下来，我们需要初始化 $f[0][i][j]$，在没有使用传送的情况下，我们只能通过向右或向下移动到达单元格 $(i, j)$。
+
+如果 $i > 0$，则可以从上方单元格 $(i-1, j)$ 移动过来，更新状态为：
+
+$$f[0][i][j] = \min(f[0][i][j], f[0][i-1][j] + grid[i][j])$$
+
+如果 $j > 0$，则可以从左侧单元格 $(i, j-1)$ 移动过来，更新状态为：
+
+$$f[0][i][j] = \min(f[0][i][j], f[0][i][j-1] + grid[i][j])$$
+
+为了处理传送操作，我们需要将网格中的单元格按其值进行分组。我们使用一个哈希表 $g$，其中键为单元格的值，值为具有该值的单元格坐标列表。
+
+对于每次传送 $t$ 从 $1$ 到 $k$，我们按照单元格值从大到小的顺序处理每个组。对于每个组中的单元格 $(i, j)$，我们首先更新一个全局最小值 $mn$，它表示在使用 $t-1$ 次传送时到达这些单元格的最小成本：
+
+$$mn = \min(mn, f[t-1][i][j])$$
+
+然后，我们将组中所有单元格的状态更新为 $mn$，表示通过传送到达这些单元格的最小成本。
+
+接下来，我们再次遍历整个网格，更新 $f[t][i][j]$，考虑从上方或左侧单元格移动过来的情况：
+
+如果 $i > 0$，则：
+
+$$f[t][i][j] = \min(f[t][i][j], f[t][i-1][j] + grid[i][j])$$
+
+如果 $j > 0$，则：
+
+$$f[t][i][j] = \min(f[t][i][j], f[t][i][j-1] + grid[i][j])$$
+
+最终，我们的答案是 $\min(f[t][m-1][n-1])$，其中 $t$ 从 $0$ 到 $k$。
+
+时间复杂度 $O((k + \log mn) \times mn)$，空间复杂度 $O(k \times mn)$。其中 $m$ 和 $n$ 分别是网格的行数和列数，而 $k$ 是允许的最大传送次数。
 
 <!-- tabs:start -->
 
@@ -458,6 +492,74 @@ function minCost(grid: number[][], k: number): number {
 }
 ```
 
+#### Rust
+
+```rust
+use std::collections::HashMap;
+
+impl Solution {
+    pub fn min_cost(grid: Vec<Vec<i32>>, k: i32) -> i32 {
+        let m = grid.len();
+        let n = grid[0].len();
+        let k = k as usize;
+        let inf: i32 = i32::MAX / 2;
+
+        let mut f = vec![vec![vec![inf; n]; m]; k + 1];
+
+        f[0][0][0] = 0;
+        for i in 0..m {
+            for j in 0..n {
+                if i > 0 {
+                    f[0][i][j] = f[0][i][j].min(f[0][i - 1][j] + grid[i][j]);
+                }
+                if j > 0 {
+                    f[0][i][j] = f[0][i][j].min(f[0][i][j - 1] + grid[i][j]);
+                }
+            }
+        }
+
+        let mut g: HashMap<i32, Vec<(usize, usize)>> = HashMap::new();
+        for i in 0..m {
+            for j in 0..n {
+                g.entry(grid[i][j]).or_default().push((i, j));
+            }
+        }
+
+        let mut keys: Vec<i32> = g.keys().cloned().collect();
+        keys.sort_by(|a, b| b.cmp(a));
+
+        for t in 1..=k {
+            let mut mn = inf;
+            for &key in &keys {
+                let pos = &g[&key];
+                for &(i, j) in pos {
+                    mn = mn.min(f[t - 1][i][j]);
+                }
+                for &(i, j) in pos {
+                    f[t][i][j] = mn;
+                }
+            }
+            for i in 0..m {
+                for j in 0..n {
+                    if i > 0 {
+                        f[t][i][j] = f[t][i][j].min(f[t][i - 1][j] + grid[i][j]);
+                    }
+                    if j > 0 {
+                        f[t][i][j] = f[t][i][j].min(f[t][i][j - 1] + grid[i][j]);
+                    }
+                }
+            }
+        }
+
+        let mut ans = inf;
+        for t in 0..=k {
+            ans = ans.min(f[t][m - 1][n - 1]);
+        }
+        ans
+    }
+}
+```
+
 <!-- tabs:end -->
 
 <!-- solution:end -->

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

@@ -135,7 +135,41 @@ source: Biweekly Contest 163 Q4
 
 <!-- solution:start -->
 
-### Solution 1
+### Solution 1: Dynamic Programming
+
+We define $f[t][i][j]$ as the minimum cost to reach cell $(i, j)$ using exactly $t$ teleportations. Initially, $f[0][0][0] = 0$, and all other states are infinity.
+
+First, we need to initialize $f[0][i][j]$. Without using teleportation, we can only reach cell $(i, j)$ by moving right or down.
+
+If $i > 0$, we can move from the cell above $(i-1, j)$, updating the state as:
+
+$$f[0][i][j] = \min(f[0][i][j], f[0][i-1][j] + grid[i][j])$$
+
+If $j > 0$, we can move from the cell to the left $(i, j-1)$, updating the state as:
+
+$$f[0][i][j] = \min(f[0][i][j], f[0][i][j-1] + grid[i][j])$$
+
+To handle teleportation, we need to group the cells in the grid by their values. We use a hash map $g$, where the key is the cell value and the value is a list of coordinates of cells with that value.
+
+For each teleportation count $t$ from $1$ to $k$, we process each group in descending order of cell values. For each cell $(i, j)$ in a group, we first update a global minimum $mn$, representing the minimum cost to reach these cells using $t-1$ teleportations:
+
+$$mn = \min(mn, f[t-1][i][j])$$
+
+Then, we update the state of all cells in the group to $mn$, representing the minimum cost to reach these cells via teleportation.
+
+Next, we traverse the entire grid again to update $f[t][i][j]$, considering moves from the top or left cells:
+
+If $i > 0$, then:
+
+$$f[t][i][j] = \min(f[t][i][j], f[t][i-1][j] + grid[i][j])$$
+
+If $j > 0$, then:
+
+$$f[t][i][j] = \min(f[t][i][j], f[t][i][j-1] + grid[i][j])$$
+
+Finally, our answer is $\min(f[t][m-1][n-1])$, where $t$ ranges from $0$ to $k$.
+
+The time complexity is $O((k + \log mn) \times mn)$, and the space complexity is $O(k \times mn)$. Here, $m$ and $n$ are the number of rows and columns of the grid, respectively, and $k$ is the maximum allowed number of teleportations.
 
 <!-- tabs:start -->
 
@@ -455,6 +489,74 @@ function minCost(grid: number[][], k: number): number {
 }
 ```
 
+#### Rust
+
+```rust
+use std::collections::HashMap;
+
+impl Solution {
+    pub fn min_cost(grid: Vec<Vec<i32>>, k: i32) -> i32 {
+        let m = grid.len();
+        let n = grid[0].len();
+        let k = k as usize;
+        let inf: i32 = i32::MAX / 2;
+
+        let mut f = vec![vec![vec![inf; n]; m]; k + 1];
+
+        f[0][0][0] = 0;
+        for i in 0..m {
+            for j in 0..n {
+                if i > 0 {
+                    f[0][i][j] = f[0][i][j].min(f[0][i - 1][j] + grid[i][j]);
+                }
+                if j > 0 {
+                    f[0][i][j] = f[0][i][j].min(f[0][i][j - 1] + grid[i][j]);
+                }
+            }
+        }
+
+        let mut g: HashMap<i32, Vec<(usize, usize)>> = HashMap::new();
+        for i in 0..m {
+            for j in 0..n {
+                g.entry(grid[i][j]).or_default().push((i, j));
+            }
+        }
+
+        let mut keys: Vec<i32> = g.keys().cloned().collect();
+        keys.sort_by(|a, b| b.cmp(a));
+
+        for t in 1..=k {
+            let mut mn = inf;
+            for &key in &keys {
+                let pos = &g[&key];
+                for &(i, j) in pos {
+                    mn = mn.min(f[t - 1][i][j]);
+                }
+                for &(i, j) in pos {
+                    f[t][i][j] = mn;
+                }
+            }
+            for i in 0..m {
+                for j in 0..n {
+                    if i > 0 {
+                        f[t][i][j] = f[t][i][j].min(f[t][i - 1][j] + grid[i][j]);
+                    }
+                    if j > 0 {
+                        f[t][i][j] = f[t][i][j].min(f[t][i][j - 1] + grid[i][j]);
+                    }
+                }
+            }
+        }
+
+        let mut ans = inf;
+        for t in 0..=k {
+            ans = ans.min(f[t][m - 1][n - 1]);
+        }
+        ans
+    }
+}
+```
+
 <!-- tabs:end -->
 
 <!-- solution:end -->

solution/3600-3699/3651.Minimum Cost Path with Teleportations/Solution.rs

@@ -0,0 +1,63 @@
+use std::collections::HashMap;
+
+impl Solution {
+    pub fn min_cost(grid: Vec<Vec<i32>>, k: i32) -> i32 {
+        let m = grid.len();
+        let n = grid[0].len();
+        let k = k as usize;
+        let inf: i32 = i32::MAX / 2;
+
+        let mut f = vec![vec![vec![inf; n]; m]; k + 1];
+
+        f[0][0][0] = 0;
+        for i in 0..m {
+            for j in 0..n {
+                if i > 0 {
+                    f[0][i][j] = f[0][i][j].min(f[0][i - 1][j] + grid[i][j]);
+                }
+                if j > 0 {
+                    f[0][i][j] = f[0][i][j].min(f[0][i][j - 1] + grid[i][j]);
+                }
+            }
+        }
+
+        let mut g: HashMap<i32, Vec<(usize, usize)>> = HashMap::new();
+        for i in 0..m {
+            for j in 0..n {
+                g.entry(grid[i][j]).or_default().push((i, j));
+            }
+        }
+
+        let mut keys: Vec<i32> = g.keys().cloned().collect();
+        keys.sort_by(|a, b| b.cmp(a));
+
+        for t in 1..=k {
+            let mut mn = inf;
+            for &key in &keys {
+                let pos = &g[&key];
+                for &(i, j) in pos {
+                    mn = mn.min(f[t - 1][i][j]);
+                }
+                for &(i, j) in pos {
+                    f[t][i][j] = mn;
+                }
+            }
+            for i in 0..m {
+                for j in 0..n {
+                    if i > 0 {
+                        f[t][i][j] = f[t][i][j].min(f[t][i - 1][j] + grid[i][j]);
+                    }
+                    if j > 0 {
+                        f[t][i][j] = f[t][i][j].min(f[t][i][j - 1] + grid[i][j]);
+                    }
+                }
+            }
+        }
+
+        let mut ans = inf;
+        for t in 0..=k {
+            ans = ans.min(f[t][m - 1][n - 1]);
+        }
+        ans
+    }
+}