feat: add solutions to lc problem: No.0980

No.0980.Unique Paths III

Author: yanglbme

solution/0900-0999/0980.Unique Paths III/README.md

@@ -60,22 +60,186 @@
 
 <!-- 这里可写通用的实现逻辑 -->
 
+**方法一：回溯**
+
+我们可以先遍历整个网格，找出起点 $(x, y)$，并且统计空白格的数量 $cnt$。
+
+接下来，我们可以从起点开始搜索，得到所有的路径数。我们设计一个函数 $dfs(i, j, k)$ 表示从 $(i, j)$ 出发，且当前已经走过的单元格数量为 $k$ 的路径数。
+
+在函数中，我们首先判断当前单元格是否为终点，如果是，则判断 $k$ 是否等于 $cnt + 1$，如果是，则说明当前路径是一条有效路径，返回 $1$，否则返回 $0$。
+
+如果当前单元格不是终点，则我们枚举当前单元格的上下左右四个邻接单元格，如果邻接单元格未被访问过，则我们将该邻接单元格标记为已访问，然后继续搜索从该邻接单元格出发的路径数，搜索完成后，我们再将该邻接单元格标记为未访问。在搜索完成后，我们返回所有邻接单元格的路径数之和。
+
+最后，我们返回从起点出发的路径数即可，即 $dfs(x, y, 1)$。
+
+时间复杂度 $O(4^{m \times n})$，空间复杂度 $O(m \times n)$。其中 $m$ 和 $n$ 分别为网格的行数和列数。
+
 <!-- tabs:start -->
 
 ### **Python3**
 
 <!-- 这里可写当前语言的特殊实现逻辑 -->
 
 ```python
-
+class Solution:
+    def uniquePathsIII(self, grid: List[List[int]]) -> int:
+        def dfs(i, j, k):
+            if grid[i][j] == 2:
+                return int(k == cnt + 1)
+            ans = 0
+            for a, b in pairwise(dirs):
+                x, y = i + a, j + b
+                if 0 <= x < m and 0 <= y < n and (x, y) not in vis and grid[x][y] != -1:
+                    vis.add((x, y))
+                    ans += dfs(x, y, k + 1)
+                    vis.remove((x, y))
+            return ans
+
+        m, n = len(grid), len(grid[0])
+        start = next((i, j) for i in range(m)
+                     for j in range(n) if grid[i][j] == 1)
+        dirs = (-1, 0, 1, 0, -1)
+        cnt = sum(grid[i][j] == 0 for i in range(m) for j in range(n))
+        vis = {start}
+        return dfs(*start, 0)
 ```
 
 ### **Java**
 
 <!-- 这里可写当前语言的特殊实现逻辑 -->
 
 ```java
+class Solution {
+    private int m;
+    private int n;
+    private int cnt;
+    private int[][] grid;
+    private boolean[][] vis;
+
+    public int uniquePathsIII(int[][] grid) {
+        m = grid.length;
+        n = grid[0].length;
+        this.grid = grid;
+        int x = 0, y = 0;
+        for (int i = 0; i < m; ++i) {
+            for (int j = 0; j < n; ++j) {
+                if (grid[i][j] == 0) {
+                    ++cnt;
+                } else if (grid[i][j] == 1) {
+                    x = i;
+                    y = j;
+                }
+            }
+        }
+        vis = new boolean[m][n];
+        vis[x][y] = true;
+        return dfs(x, y, 0);
+    }
+
+    private int dfs(int i, int j, int k) {
+        if (grid[i][j] == 2) {
+            return k == cnt + 1 ? 1 : 0;
+        }
+        int ans = 0;
+        int[] dirs = {-1, 0, 1, 0, -1};
+        for (int h = 0; h < 4; ++h) {
+            int x = i + dirs[h], y = j + dirs[h + 1];
+            if (x >= 0 && x < m && y >= 0 && y < n && !vis[x][y] && grid[x][y] != -1) {
+                vis[x][y] = true;
+                ans += dfs(x, y, k + 1);
+                vis[x][y] = false;
+            }
+        }
+        return ans;
+    }
+}
+```
+
+### **C++**
+
+```cpp
+class Solution {
+public:
+    int uniquePathsIII(vector<vector<int>>& grid) {
+        int m = grid.size(), n = grid[0].size();
+        int cnt = 0;
+        for (auto& row : grid) {
+            for (auto& x : row) {
+                cnt += x == 0;
+            }
+        }
+        int dirs[5] = {-1, 0, 1, 0, -1};
+        bool vis[m][n];
+        memset(vis, false, sizeof vis);
+        function<int(int, int, int)> dfs = [&](int i, int j, int k) -> int {
+            if (grid[i][j] == 2) {
+                return k == cnt + 1 ? 1 : 0;
+            }
+            int ans = 0;
+            for (int h = 0; h < 4; ++h) {
+                int x = i + dirs[h], y = j + dirs[h + 1];
+                if (x >= 0 && x < m && y >= 0 && y < n && !vis[x][y] && grid[x][y] != -1) {
+                    vis[x][y] = true;
+                    ans += dfs(x, y, k + 1);
+                    vis[x][y] = false;
+                }
+            }
+            return ans;
+        };
+        for (int i = 0; i < m; ++i) {
+            for (int j = 0; j < n; ++j) {
+                if (grid[i][j] == 1) {
+                    vis[i][j] = true;
+                    return dfs(i, j, 0);
+                }
+            }
+        }
+        return 0;
+    }
+};
+```
 
+### **Go**
+
+```go
+func uniquePathsIII(grid [][]int) int {
+	m, n := len(grid), len(grid[0])
+	cnt := 0
+	vis := make([][]bool, m)
+	x, y := 0, 0
+	for i, row := range grid {
+		vis[i] = make([]bool, n)
+		for j, v := range row {
+			if v == 0 {
+				cnt++
+			} else if v == 1 {
+				x, y = i, j
+			}
+		}
+	}
+	dirs := [5]int{-1, 0, 1, 0, -1}
+	var dfs func(i, j, k int) int
+	dfs = func(i, j, k int) int {
+		if grid[i][j] == 2 {
+			if k == cnt+1 {
+				return 1
+			}
+			return 0
+		}
+		ans := 0
+		for h := 0; h < 4; h++ {
+			x, y := i+dirs[h], j+dirs[h+1]
+			if x >= 0 && x < m && y >= 0 && y < n && !vis[x][y] && grid[x][y] != -1 {
+				vis[x][y] = true
+				ans += dfs(x, y, k+1)
+				vis[x][y] = false
+			}
+		}
+		return ans
+	}
+	vis[x][y] = true
+	return dfs(x, y, 0)
+}
 ```
 
 ### **...**

solution/0900-0999/0980.Unique Paths III/README_EN.md

@@ -66,13 +66,163 @@ Note that the starting and ending square can be anywhere in the grid.
 ### **Python3**
 
 ```python
-
+class Solution:
+    def uniquePathsIII(self, grid: List[List[int]]) -> int:
+        def dfs(i, j, k):
+            if grid[i][j] == 2:
+                return int(k == cnt + 1)
+            ans = 0
+            for a, b in pairwise(dirs):
+                x, y = i + a, j + b
+                if 0 <= x < m and 0 <= y < n and (x, y) not in vis and grid[x][y] != -1:
+                    vis.add((x, y))
+                    ans += dfs(x, y, k + 1)
+                    vis.remove((x, y))
+            return ans
+
+        m, n = len(grid), len(grid[0])
+        start = next((i, j) for i in range(m)
+                     for j in range(n) if grid[i][j] == 1)
+        dirs = (-1, 0, 1, 0, -1)
+        cnt = sum(grid[i][j] == 0 for i in range(m) for j in range(n))
+        vis = {start}
+        return dfs(*start, 0)
 ```
 
 ### **Java**
 
 ```java
+class Solution {
+    private int m;
+    private int n;
+    private int cnt;
+    private int[][] grid;
+    private boolean[][] vis;
+
+    public int uniquePathsIII(int[][] grid) {
+        m = grid.length;
+        n = grid[0].length;
+        this.grid = grid;
+        int x = 0, y = 0;
+        for (int i = 0; i < m; ++i) {
+            for (int j = 0; j < n; ++j) {
+                if (grid[i][j] == 0) {
+                    ++cnt;
+                } else if (grid[i][j] == 1) {
+                    x = i;
+                    y = j;
+                }
+            }
+        }
+        vis = new boolean[m][n];
+        vis[x][y] = true;
+        return dfs(x, y, 0);
+    }
+
+    private int dfs(int i, int j, int k) {
+        if (grid[i][j] == 2) {
+            return k == cnt + 1 ? 1 : 0;
+        }
+        int ans = 0;
+        int[] dirs = {-1, 0, 1, 0, -1};
+        for (int h = 0; h < 4; ++h) {
+            int x = i + dirs[h], y = j + dirs[h + 1];
+            if (x >= 0 && x < m && y >= 0 && y < n && !vis[x][y] && grid[x][y] != -1) {
+                vis[x][y] = true;
+                ans += dfs(x, y, k + 1);
+                vis[x][y] = false;
+            }
+        }
+        return ans;
+    }
+}
+```
+
+### **C++**
+
+```cpp
+class Solution {
+public:
+    int uniquePathsIII(vector<vector<int>>& grid) {
+        int m = grid.size(), n = grid[0].size();
+        int cnt = 0;
+        for (auto& row : grid) {
+            for (auto& x : row) {
+                cnt += x == 0;
+            }
+        }
+        int dirs[5] = {-1, 0, 1, 0, -1};
+        bool vis[m][n];
+        memset(vis, false, sizeof vis);
+        function<int(int, int, int)> dfs = [&](int i, int j, int k) -> int {
+            if (grid[i][j] == 2) {
+                return k == cnt + 1 ? 1 : 0;
+            }
+            int ans = 0;
+            for (int h = 0; h < 4; ++h) {
+                int x = i + dirs[h], y = j + dirs[h + 1];
+                if (x >= 0 && x < m && y >= 0 && y < n && !vis[x][y] && grid[x][y] != -1) {
+                    vis[x][y] = true;
+                    ans += dfs(x, y, k + 1);
+                    vis[x][y] = false;
+                }
+            }
+            return ans;
+        };
+        for (int i = 0; i < m; ++i) {
+            for (int j = 0; j < n; ++j) {
+                if (grid[i][j] == 1) {
+                    vis[i][j] = true;
+                    return dfs(i, j, 0);
+                }
+            }
+        }
+        return 0;
+    }
+};
+```
 
+### **Go**
+
+```go
+func uniquePathsIII(grid [][]int) int {
+	m, n := len(grid), len(grid[0])
+	cnt := 0
+	vis := make([][]bool, m)
+	x, y := 0, 0
+	for i, row := range grid {
+		vis[i] = make([]bool, n)
+		for j, v := range row {
+			if v == 0 {
+				cnt++
+			} else if v == 1 {
+				x, y = i, j
+			}
+		}
+	}
+	dirs := [5]int{-1, 0, 1, 0, -1}
+	var dfs func(i, j, k int) int
+	dfs = func(i, j, k int) int {
+		if grid[i][j] == 2 {
+			if k == cnt+1 {
+				return 1
+			}
+			return 0
+		}
+		ans := 0
+		for h := 0; h < 4; h++ {
+			x, y := i+dirs[h], j+dirs[h+1]
+			if x >= 0 && x < m && y >= 0 && y < n && !vis[x][y] && grid[x][y] != -1 {
+				vis[x][y] = true
+				ans += dfs(x, y, k+1)
+				vis[x][y] = false
+			}
+		}
+		return ans
+	}
+	vis[x][y] = true
+	return dfs(x, y, 0)
+}
 ```
 
 ### **...**

solution/0900-0999/0980.Unique Paths III/Solution.cpp

@@ -0,0 +1,39 @@
+class Solution {
+public:
+    int uniquePathsIII(vector<vector<int>>& grid) {
+        int m = grid.size(), n = grid[0].size();
+        int cnt = 0;
+        for (auto& row : grid) {
+            for (auto& x : row) {
+                cnt += x == 0;
+            }
+        }
+        int dirs[5] = {-1, 0, 1, 0, -1};
+        bool vis[m][n];
+        memset(vis, false, sizeof vis);
+        function<int(int, int, int)> dfs = [&](int i, int j, int k) -> int {
+            if (grid[i][j] == 2) {
+                return k == cnt + 1 ? 1 : 0;
+            }
+            int ans = 0;
+            for (int h = 0; h < 4; ++h) {
+                int x = i + dirs[h], y = j + dirs[h + 1];
+                if (x >= 0 && x < m && y >= 0 && y < n && !vis[x][y] && grid[x][y] != -1) {
+                    vis[x][y] = true;
+                    ans += dfs(x, y, k + 1);
+                    vis[x][y] = false;
+                }
+            }
+            return ans;
+        };
+        for (int i = 0; i < m; ++i) {
+            for (int j = 0; j < n; ++j) {
+                if (grid[i][j] == 1) {
+                    vis[i][j] = true;
+                    return dfs(i, j, 0);
+                }
+            }
+        }
+        return 0;
+    }
+};