feat: add rust solution to lc problem: No.0403 (#1525)

Author: xzhseh

solution/0400-0499/0403.Frog Jump/README.md

@@ -230,6 +230,77 @@ public:
 };
 ```
 
+### **Rust**
+
+```rust
+use std::collections::HashMap;
+
+impl Solution {
+    #[allow(dead_code)]
+    pub fn can_cross(stones: Vec<i32>) -> bool {
+        let n = stones.len();
+        let mut record = vec![vec![-1; n]; n];
+        let mut pos = HashMap::new();
+        for (i, &s) in stones.iter().enumerate() {
+            pos.insert(s, i);
+        }
+
+        Self::dfs(&mut record, 0, 0, n, &pos, &stones)
+    }
+
+    #[allow(dead_code)]
+    fn dfs(record: &mut Vec<Vec<i32>>, i: usize, k: usize, n: usize, pos: &HashMap<i32, usize>, stones: &Vec<i32>) -> bool {
+        if i == n - 1 {
+            return true;
+        }
+
+        if record[i][k] != -1 {
+            return record[i][k] == 1;
+        }
+
+        let k = k as i32;
+        for j in k - 1..=k + 1 {
+            if j > 0 && pos.contains_key(&(stones[i] + j)) && Self::dfs(record, pos[&(stones[i] + j)], j as usize, n, pos, stones) {
+                record[i][k as usize] = 1;
+                return true;
+            }
+        }
+
+        record[i][k as usize] = 0;
+        false
+    }
+}
+```
+
+```rust
+impl Solution {
+    #[allow(dead_code)]
+    pub fn can_cross(stones: Vec<i32>) -> bool {
+        let n = stones.len();
+        let mut dp = vec![vec![false; n]; n];
+
+        // Initialize the dp vector
+        dp[0][0] = true;
+
+        // Begin the actual dp process
+        for i in 1..n {
+            for j in (0..=i - 1).rev() {
+                let k = (stones[i] - stones[j]) as usize;
+                if k - 1 > j {
+                    break;
+                }
+                dp[i][k] = dp[j][k - 1] || dp[j][k] || dp[j][k + 1];
+                if i == n - 1 && dp[i][k] {
+                    return true;
+                }
+            }
+        }
+
+        false
+    }
+}
+```
+
 ### **Go**
 
 ```go

solution/0400-0499/0403.Frog Jump/README_EN.md

@@ -222,6 +222,77 @@ public:
 };
 ```
 
+### **Rust**
+
+```rust
+use std::collections::HashMap;
+
+impl Solution {
+    #[allow(dead_code)]
+    pub fn can_cross(stones: Vec<i32>) -> bool {
+        let n = stones.len();
+        let mut record = vec![vec![-1; n]; n];
+        let mut pos = HashMap::new();
+        for (i, &s) in stones.iter().enumerate() {
+            pos.insert(s, i);
+        }
+
+        Self::dfs(&mut record, 0, 0, n, &pos, &stones)
+    }
+
+    #[allow(dead_code)]
+    fn dfs(record: &mut Vec<Vec<i32>>, i: usize, k: usize, n: usize, pos: &HashMap<i32, usize>, stones: &Vec<i32>) -> bool {
+        if i == n - 1 {
+            return true;
+        }
+
+        if record[i][k] != -1 {
+            return record[i][k] == 1;
+        }
+
+        let k = k as i32;
+        for j in k - 1..=k + 1 {
+            if j > 0 && pos.contains_key(&(stones[i] + j)) && Self::dfs(record, pos[&(stones[i] + j)], j as usize, n, pos, stones) {
+                record[i][k as usize] = 1;
+                return true;
+            }
+        }
+
+        record[i][k as usize] = 0;
+        false
+    }
+}
+```
+
+```rust
+impl Solution {
+    #[allow(dead_code)]
+    pub fn can_cross(stones: Vec<i32>) -> bool {
+        let n = stones.len();
+        let mut dp = vec![vec![false; n]; n];
+
+        // Initialize the dp vector
+        dp[0][0] = true;
+
+        // Begin the actual dp process
+        for i in 1..n {
+            for j in (0..=i - 1).rev() {
+                let k = (stones[i] - stones[j]) as usize;
+                if k - 1 > j {
+                    break;
+                }
+                dp[i][k] = dp[j][k - 1] || dp[j][k] || dp[j][k + 1];
+                if i == n - 1 && dp[i][k] {
+                    return true;
+                }
+            }
+        }
+
+        false
+    }
+}
+```
+
 ### **Go**
 
 ```go

solution/0400-0499/0403.Frog Jump/Solution.rs

@@ -0,0 +1,26 @@
+impl Solution {
+    #[allow(dead_code)]
+    pub fn can_cross(stones: Vec<i32>) -> bool {
+        let n = stones.len();
+        let mut dp = vec![vec![false; n]; n];
+
+        // Initialize the dp vector
+        dp[0][0] = true;
+
+        // Begin the actual dp process
+        for i in 1..n {
+            for j in (0..=i - 1).rev() {
+                let k = (stones[i] - stones[j]) as usize;
+                if k - 1 > j {
+                    break;
+                }
+                dp[i][k] = dp[j][k - 1] || dp[j][k] || dp[j][k + 1];
+                if i == n - 1 && dp[i][k] {
+                    return true;
+                }
+            }
+        }
+
+        false
+    }
+}