feat: add rust solution for lc No.2770 (#5190)

Author: yanglbme

solution/2700-2799/2770.Maximum Number of Jumps to Reach the Last Index/README.md

@@ -39,28 +39,28 @@ tags:
 <pre><strong>输入：</strong>nums = [1,3,6,4,1,2], target = 2
 <strong>输出：</strong>3
 <strong>解释：</strong>要想以最大跳跃次数从下标 0 到下标 n - 1 ，可以按下述跳跃序列执行操作：
-- 从下标 0 跳跃到下标 1 。 
-- 从下标 1 跳跃到下标 3 。 
-- 从下标 3 跳跃到下标 5 。 
+- 从下标 0 跳跃到下标 1 。
+- 从下标 1 跳跃到下标 3 。
+- 从下标 3 跳跃到下标 5 。
 可以证明，从 0 到 n - 1 的所有方案中，不存在比 3 步更长的跳跃序列。因此，答案是 3 。 </pre>
 
 <p><strong>示例 2：</strong></p>
 
 <pre><strong>输入：</strong>nums = [1,3,6,4,1,2], target = 3
 <strong>输出：</strong>5
 <strong>解释：</strong>要想以最大跳跃次数从下标 0 到下标 n - 1 ，可以按下述跳跃序列执行操作：
-- 从下标 0 跳跃到下标 1 。 
-- 从下标 1 跳跃到下标 2 。 
-- 从下标 2 跳跃到下标 3 。 
-- 从下标 3 跳跃到下标 4 。 
-- 从下标 4 跳跃到下标 5 。 
+- 从下标 0 跳跃到下标 1 。
+- 从下标 1 跳跃到下标 2 。
+- 从下标 2 跳跃到下标 3 。
+- 从下标 3 跳跃到下标 4 。
+- 从下标 4 跳跃到下标 5 。
 可以证明，从 0 到 n - 1 的所有方案中，不存在比 5 步更长的跳跃序列。因此，答案是 5 。 </pre>
 
 <p><strong>示例 3：</strong></p>
 
 <pre><strong>输入：</strong>nums = [1,3,6,4,1,2], target = 0
 <strong>输出：</strong>-1
-<strong>解释：</strong>可以证明不存在从 0 到 n - 1 的跳跃序列。因此，答案是 -1 。 
+<strong>解释：</strong>可以证明不存在从 0 到 n - 1 的跳跃序列。因此，答案是 -1 。
 </pre>
 
 <p>&nbsp;</p>
@@ -161,7 +161,7 @@ public:
         int n = nums.size();
         int f[n];
         memset(f, -1, sizeof(f));
-        function<int(int)> dfs = [&](int i) {
+        auto dfs = [&](this auto&& dfs, int i) -> int {
             if (i == n - 1) {
                 return 0;
             }
@@ -248,6 +248,36 @@ function maximumJumps(nums: number[], target: number): number {
 }
 ```
 
+#### Rust
+
+```rust
+impl Solution {
+    pub fn maximum_jumps(nums: Vec<i32>, target: i32) -> i32 {
+        let n = nums.len();
+        let mut f = vec![-1; n];
+
+        fn dfs(i: usize, nums: &Vec<i32>, target: i32, f: &mut Vec<i32>) -> i32 {
+            if i == nums.len() - 1 {
+                return 0;
+            }
+            if f[i] != -1 {
+                return f[i];
+            }
+            f[i] = -(1 << 30);
+            for j in i + 1..nums.len() {
+                if (nums[i] - nums[j]).abs() <= target {
+                    f[i] = f[i].max(1 + dfs(j, nums, target, f));
+                }
+            }
+            f[i]
+        }
+
+        let ans = dfs(0, &nums, target, &mut f);
+        if ans < 0 { -1 } else { ans }
+    }
+}
+```
+
 <!-- tabs:end -->
 
 <!-- solution:end -->

solution/2700-2799/2770.Maximum Number of Jumps to Reach the Last Index/README_EN.md

@@ -39,7 +39,7 @@ tags:
 <strong>Input:</strong> nums = [1,3,6,4,1,2], target = 2
 <strong>Output:</strong> 3
 <strong>Explanation:</strong> To go from index 0 to index n - 1 with the maximum number of jumps, you can perform the following jumping sequence:
-- Jump from index 0 to index 1. 
+- Jump from index 0 to index 1.
 - Jump from index 1 to index 3.
 - Jump from index 3 to index 5.
 It can be proven that there is no other jumping sequence that goes from 0 to n - 1 with more than 3 jumps. Hence, the answer is 3. </pre>
@@ -62,7 +62,7 @@ It can be proven that there is no other jumping sequence that goes from 0 to n -
 <pre>
 <strong>Input:</strong> nums = [1,3,6,4,1,2], target = 0
 <strong>Output:</strong> -1
-<strong>Explanation:</strong> It can be proven that there is no jumping sequence that goes from 0 to n - 1. Hence, the answer is -1. 
+<strong>Explanation:</strong> It can be proven that there is no jumping sequence that goes from 0 to n - 1. Hence, the answer is -1.
 </pre>
 
 <p>&nbsp;</p>
@@ -162,7 +162,7 @@ public:
         int n = nums.size();
         int f[n];
         memset(f, -1, sizeof(f));
-        function<int(int)> dfs = [&](int i) {
+        auto dfs = [&](this auto&& dfs, int i) -> int {
             if (i == n - 1) {
                 return 0;
             }
@@ -249,6 +249,36 @@ function maximumJumps(nums: number[], target: number): number {
 }
 ```
 
+#### Rust
+
+```rust
+impl Solution {
+    pub fn maximum_jumps(nums: Vec<i32>, target: i32) -> i32 {
+        let n = nums.len();
+        let mut f = vec![-1; n];
+
+        fn dfs(i: usize, nums: &Vec<i32>, target: i32, f: &mut Vec<i32>) -> i32 {
+            if i == nums.len() - 1 {
+                return 0;
+            }
+            if f[i] != -1 {
+                return f[i];
+            }
+            f[i] = -(1 << 30);
+            for j in i + 1..nums.len() {
+                if (nums[i] - nums[j]).abs() <= target {
+                    f[i] = f[i].max(1 + dfs(j, nums, target, f));
+                }
+            }
+            f[i]
+        }
+
+        let ans = dfs(0, &nums, target, &mut f);
+        if ans < 0 { -1 } else { ans }
+    }
+}
+```
+
 <!-- tabs:end -->
 
 <!-- solution:end -->

solution/2700-2799/2770.Maximum Number of Jumps to Reach the Last Index/Solution.cpp

@@ -4,7 +4,7 @@ class Solution {
         int n = nums.size();
         int f[n];
         memset(f, -1, sizeof(f));
-        function<int(int)> dfs = [&](int i) {
+        auto dfs = [&](this auto&& dfs, int i) -> int {
             if (i == n - 1) {
                 return 0;
             }
@@ -22,4 +22,4 @@ class Solution {
         int ans = dfs(0);
         return ans < 0 ? -1 : ans;
     }
-};
+};

solution/2700-2799/2770.Maximum Number of Jumps to Reach the Last Index/Solution.rs

@@ -0,0 +1,25 @@
+impl Solution {
+    pub fn maximum_jumps(nums: Vec<i32>, target: i32) -> i32 {
+        let n = nums.len();
+        let mut f = vec![-1; n];
+
+        fn dfs(i: usize, nums: &Vec<i32>, target: i32, f: &mut Vec<i32>) -> i32 {
+            if i == nums.len() - 1 {
+                return 0;
+            }
+            if f[i] != -1 {
+                return f[i];
+            }
+            f[i] = -(1 << 30);
+            for j in i + 1..nums.len() {
+                if (nums[i] - nums[j]).abs() <= target {
+                    f[i] = f[i].max(1 + dfs(j, nums, target, f));
+                }
+            }
+            f[i]
+        }
+
+        let ans = dfs(0, &nums, target, &mut f);
+        if ans < 0 { -1 } else { ans }
+    }
+}