feat: add rust solution to lc problems: No.0130,0797,1091

- No.0130.Surrounded Regions
- No.0797.All Paths From Source to Target
- No.1091.Shortest Path in Binary Matrix

Author: YangFong

solution/0100-0199/0130.Surrounded Regions/README.md

@@ -458,6 +458,53 @@ func solve(board [][]byte) {
 }
 ```
 
+### **Rust**
+
+```rust
+impl Solution {
+    fn dfs(i: usize, j: usize, mark: char, vis: &mut Vec<Vec<bool>>, board: &mut Vec<Vec<char>>) {
+        if vis[i][j] || board[i][j] != mark {
+            return;
+        }
+        vis[i][j] = true;
+        if i > 0 {
+            Self::dfs(i - 1, j, mark, vis, board);
+        }
+        if i < vis.len() - 1 {
+            Self::dfs(i + 1, j, mark, vis, board);
+        }
+        if j > 0 {
+            Self::dfs(i, j - 1, mark, vis, board);
+        }
+        if j < vis[0].len() - 1 {
+            Self::dfs(i, j + 1, mark, vis, board);
+        }
+    }
+
+    pub fn solve(board: &mut Vec<Vec<char>>) {
+        let m = board.len();
+        let n = board[0].len();
+        let mut vis = vec![vec![false; n]; m];
+        for i in 0..m {
+            Self::dfs(i, 0, board[i][0], &mut vis, board);
+            Self::dfs(i, n - 1, board[i][n - 1], &mut vis, board);
+        }
+        for i in 0..n {
+            Self::dfs(0, i, board[0][i], &mut vis, board);
+            Self::dfs(m - 1, i, board[m - 1][i], &mut vis, board);
+        }
+        for i in 0..m {
+            for j in 0..n {
+                if vis[i][j] {
+                    continue;
+                }
+                board[i][j] = 'X';
+            }
+        }
+    }
+}
+```
+
 ### **...**
 
 ```

solution/0100-0199/0130.Surrounded Regions/README_EN.md

@@ -444,6 +444,53 @@ func solve(board [][]byte) {
 }
 ```
 
+### **Rust**
+
+```rust
+impl Solution {
+    fn dfs(i: usize, j: usize, mark: char, vis: &mut Vec<Vec<bool>>, board: &mut Vec<Vec<char>>) {
+        if vis[i][j] || board[i][j] != mark {
+            return;
+        }
+        vis[i][j] = true;
+        if i > 0 {
+            Self::dfs(i - 1, j, mark, vis, board);
+        }
+        if i < vis.len() - 1 {
+            Self::dfs(i + 1, j, mark, vis, board);
+        }
+        if j > 0 {
+            Self::dfs(i, j - 1, mark, vis, board);
+        }
+        if j < vis[0].len() - 1 {
+            Self::dfs(i, j + 1, mark, vis, board);
+        }
+    }
+
+    pub fn solve(board: &mut Vec<Vec<char>>) {
+        let m = board.len();
+        let n = board[0].len();
+        let mut vis = vec![vec![false; n]; m];
+        for i in 0..m {
+            Self::dfs(i, 0, board[i][0], &mut vis, board);
+            Self::dfs(i, n - 1, board[i][n - 1], &mut vis, board);
+        }
+        for i in 0..n {
+            Self::dfs(0, i, board[0][i], &mut vis, board);
+            Self::dfs(m - 1, i, board[m - 1][i], &mut vis, board);
+        }
+        for i in 0..m {
+            for j in 0..n {
+                if vis[i][j] {
+                    continue;
+                }
+                board[i][j] = 'X';
+            }
+        }
+    }
+}
+```
+
 ### **...**
 
 ```

solution/0100-0199/0130.Surrounded Regions/Solution.rs

@@ -0,0 +1,42 @@
+impl Solution {
+    fn dfs(i: usize, j: usize, mark: char, vis: &mut Vec<Vec<bool>>, board: &mut Vec<Vec<char>>) {
+        if vis[i][j] || board[i][j] != mark {
+            return;
+        }
+        vis[i][j] = true;
+        if i > 0 {
+            Self::dfs(i - 1, j, mark, vis, board);
+        }
+        if i < vis.len() - 1 {
+            Self::dfs(i + 1, j, mark, vis, board);
+        }
+        if j > 0 {
+            Self::dfs(i, j - 1, mark, vis, board);
+        }
+        if j < vis[0].len() - 1 {
+            Self::dfs(i, j + 1, mark, vis, board);
+        }
+    }
+
+    pub fn solve(board: &mut Vec<Vec<char>>) {
+        let m = board.len();
+        let n = board[0].len();
+        let mut vis = vec![vec![false; n]; m];
+        for i in 0..m {
+            Self::dfs(i, 0, board[i][0], &mut vis, board);
+            Self::dfs(i, n - 1, board[i][n - 1], &mut vis, board);
+        }
+        for i in 0..n {
+            Self::dfs(0, i, board[0][i], &mut vis, board);
+            Self::dfs(m - 1, i, board[m - 1][i], &mut vis, board);
+        }
+        for i in 0..m {
+            for j in 0..n {
+                if vis[i][j] {
+                    continue;
+                }
+                board[i][j] = 'X';
+            }
+        }
+    }
+}

solution/0700-0799/0797.All Paths From Source to Target/README.md

@@ -249,6 +249,29 @@ var allPathsSourceTarget = function (graph) {
 };
 ```
 
+### **Rust**
+
+```rust
+impl Solution {
+    fn dfs(i: usize, path: &mut Vec<i32>, res: &mut Vec<Vec<i32>>, graph: &Vec<Vec<i32>>) {
+        path.push(i as i32);
+        if i == graph.len() - 1 {
+            res.push(path.clone());
+        }
+        for j in graph[i].iter() {
+            Self::dfs(*j as usize, path, res, graph)
+        }
+        path.pop();
+    }
+
+    pub fn all_paths_source_target(graph: Vec<Vec<i32>>) -> Vec<Vec<i32>> {
+        let mut res = Vec::new();
+        Self::dfs(0, &mut vec![], &mut res, &graph);
+        res
+    }
+}
+```
+
 ### **...**
 
 ```

solution/0700-0799/0797.All Paths From Source to Target/README_EN.md

@@ -233,6 +233,29 @@ var allPathsSourceTarget = function (graph) {
 };
 ```
 
+### **Rust**
+
+```rust
+impl Solution {
+    fn dfs(i: usize, path: &mut Vec<i32>, res: &mut Vec<Vec<i32>>, graph: &Vec<Vec<i32>>) {
+        path.push(i as i32);
+        if i == graph.len() - 1 {
+            res.push(path.clone());
+        }
+        for j in graph[i].iter() {
+            Self::dfs(*j as usize, path, res, graph)
+        }
+        path.pop();
+    }
+
+    pub fn all_paths_source_target(graph: Vec<Vec<i32>>) -> Vec<Vec<i32>> {
+        let mut res = Vec::new();
+        Self::dfs(0, &mut vec![], &mut res, &graph);
+        res
+    }
+}
+```
+
 ### **...**
 
 ```

solution/0700-0799/0797.All Paths From Source to Target/Solution.rs

@@ -0,0 +1,18 @@
+impl Solution {
+    fn dfs(i: usize, path: &mut Vec<i32>, res: &mut Vec<Vec<i32>>, graph: &Vec<Vec<i32>>) {
+        path.push(i as i32);
+        if i == graph.len() - 1 {
+            res.push(path.clone());
+        }
+        for j in graph[i].iter() {
+            Self::dfs(*j as usize, path, res, graph)
+        }
+        path.pop();
+    }
+
+    pub fn all_paths_source_target(graph: Vec<Vec<i32>>) -> Vec<Vec<i32>> {
+        let mut res = Vec::new();
+        Self::dfs(0, &mut vec![], &mut res, &graph);
+        res
+    }
+}

solution/1000-1099/1091.Shortest Path in Binary Matrix/README.md

@@ -197,6 +197,44 @@ func shortestPathBinaryMatrix(grid [][]int) int {
 }
 ```
 
+### **Rust**
+
+```rust
+use std::collections::VecDeque;
+impl Solution {
+    pub fn shortest_path_binary_matrix(mut grid: Vec<Vec<i32>>) -> i32 {
+        let n = grid.len();
+        let mut queue = VecDeque::new();
+        queue.push_back([0, 0]);
+        let mut res = 0;
+        while !queue.is_empty() {
+            res += 1;
+            for _ in 0..queue.len() {
+                let [i, j] = queue.pop_front().unwrap();
+                if grid[i][j] == 1 {
+                    continue;
+                }
+                if i == n - 1 && j == n - 1 {
+                    return res;
+                }
+                grid[i][j] = 1;
+                for x in -1..=1 {
+                    for y in -1..=1 {
+                        let x = x + i as i32;
+                        let y = y + j as i32;
+                        if x < 0 || x == n as i32 || y < 0 || y == n as i32 {
+                            continue;
+                        }
+                        queue.push_back([x as usize, y as usize]);
+                    }
+                }
+            }
+        }
+        -1
+    }
+}
+```
+
 ### **...**
 
 ```

solution/1000-1099/1091.Shortest Path in Binary Matrix/README_EN.md

@@ -187,6 +187,44 @@ func shortestPathBinaryMatrix(grid [][]int) int {
 }
 ```
 
+### **Rust**
+
+```rust
+use std::collections::VecDeque;
+impl Solution {
+    pub fn shortest_path_binary_matrix(mut grid: Vec<Vec<i32>>) -> i32 {
+        let n = grid.len();
+        let mut queue = VecDeque::new();
+        queue.push_back([0, 0]);
+        let mut res = 0;
+        while !queue.is_empty() {
+            res += 1;
+            for _ in 0..queue.len() {
+                let [i, j] = queue.pop_front().unwrap();
+                if grid[i][j] == 1 {
+                    continue;
+                }
+                if i == n - 1 && j == n - 1 {
+                    return res;
+                }
+                grid[i][j] = 1;
+                for x in -1..=1 {
+                    for y in -1..=1 {
+                        let x = x + i as i32;
+                        let y = y + j as i32;
+                        if x < 0 || x == n as i32 || y < 0 || y == n as i32 {
+                            continue;
+                        }
+                        queue.push_back([x as usize, y as usize]);
+                    }
+                }
+            }
+        }
+        -1
+    }
+}
+```
+
 ### **...**
 
 ```

solution/1000-1099/1091.Shortest Path in Binary Matrix/Solution.rs

@@ -0,0 +1,33 @@
+use std::collections::VecDeque;
+impl Solution {
+    pub fn shortest_path_binary_matrix(mut grid: Vec<Vec<i32>>) -> i32 {
+        let n = grid.len();
+        let mut queue = VecDeque::new();
+        queue.push_back([0, 0]);
+        let mut res = 0;
+        while !queue.is_empty() {
+            res += 1;
+            for _ in 0..queue.len() {
+                let [i, j] = queue.pop_front().unwrap();
+                if grid[i][j] == 1 {
+                    continue;
+                }
+                if i == n - 1 && j == n - 1 {
+                    return res;
+                }
+                grid[i][j] = 1;
+                for x in -1..=1 {
+                    for y in -1..=1 {
+                        let x = x + i as i32;
+                        let y = y + j as i32;
+                        if x < 0 || x == n as i32 || y < 0 || y == n as i32 {
+                            continue;
+                        }
+                        queue.push_back([x as usize, y as usize]);
+                    }
+                }
+            }
+        }
+        -1
+    }
+}