feat: add solutions to lc problem: No.0063. Unique Paths II

Author: yanglbme

README.md

@@ -190,6 +190,7 @@
 - [矩阵区域和](./solution/1300-1399/1314.Matrix%20Block%20Sum/README.md)
 - [二维区域和检索 - 矩阵不可变](./solution/0300-0399/0304.Range%20Sum%20Query%202D%20-%20Immutable/README.md)
 - [不同路径](./solution/0000-0099/0062.Unique%20Paths/README.md)
+- [不同路径 II](./solution/0000-0099/0063.Unique%20Paths%20II/README.md)
 - [礼物的最大价值](./lcof/面试题47.%20礼物的最大价值/README.md)
 - [最小路径和](./solution/0000-0099/0064.Minimum%20Path%20Sum/README.md)
 - [最长上升子序列](./solution/0300-0399/0300.Longest%20Increasing%20Subsequence/README.md)

README_EN.md

@@ -184,6 +184,7 @@ Complete solutions to [LeetCode](https://leetcode.com/problemset/all/), [LCOF](h
 - [Matrix Block Sum](./solution/1300-1399/1314.Matrix%20Block%20Sum/README_EN.md)
 - [Range Sum Query 2D - Immutable](./solution/0300-0399/0304.Range%20Sum%20Query%202D%20-%20Immutable/README_EN.md)
 - [Unique Paths](./solution/0000-0099/0062.Unique%20Paths/README_EN.md)
+- [Unique Paths II](./solution/0000-0099/0063.Unique%20Paths%20II/README_EN.md)
 - [Minimum Path Sum](./solution/0000-0099/0064.Minimum%20Path%20Sum/README_EN.md)
 - [Longest Increasing Subsequence](./solution/0300-0399/0300.Longest%20Increasing%20Subsequence/README_EN.md)
 - [Russian Doll Envelopes](./solution/0300-0399/0354.Russian%20Doll%20Envelopes/README_EN.md)

solution/0000-0099/0062.Unique Paths/README.md

@@ -75,7 +75,7 @@ class Solution:
         for i in range(1, m):
             for j in range(1, n):
                 dp[i][j] = dp[i - 1][j] + dp[i][j - 1]
-        return dp[m - 1][n - 1]
+        return dp[-1][-1]
 ```
 
 ### **Java**

solution/0000-0099/0062.Unique Paths/README_EN.md

@@ -54,6 +54,8 @@ From the top-left corner, there are a total of 3 ways to reach the bottom-right
 
 ## Solutions
 
+Dynamic programming.
+
 <!-- tabs:start -->
 
 ### **Python3**
@@ -65,7 +67,7 @@ class Solution:
         for i in range(1, m):
             for j in range(1, n):
                 dp[i][j] = dp[i - 1][j] + dp[i][j - 1]
-        return dp[m - 1][n - 1]
+        return dp[-1][-1]
 ```
 
 ### **Java**

solution/0000-0099/0062.Unique Paths/Solution.py

@@ -4,4 +4,4 @@ def uniquePaths(self, m: int, n: int) -> int:
         for i in range(1, m):
             for j in range(1, n):
                 dp[i][j] = dp[i - 1][j] + dp[i][j - 1]
-        return dp[m - 1][n - 1]
+        return dp[-1][-1]

solution/0000-0099/0063.Unique Paths II/README.md

@@ -48,54 +48,122 @@
 	<li><code>obstacleGrid[i][j]</code> 为 <code>0</code> 或 <code>1</code></li>
 </ul>
 
-
 ## 解法
 
 <!-- 这里可写通用的实现逻辑 -->
 
-### **Go**
+动态规划。
 
-````go
-func uniquePathsWithObstacles(obstacleGrid [][]int) int {
-    m,n := len(obstacleGrid),len(obstacleGrid[0])
-    dp := make([][]int,m)
-    for i:=0; i < m;i++ {
-        dp[i] = make([]int,n)
-    }
-    for i := 0; i < m; i++ {
-        for j := 0; j < n; j++ {
-            if obstacleGrid[i][j] == 0 {
-                if i == 0 && j == 0 {
-                    dp[i][j] = 1
-                } else if i > 0 && j >0 {
-                    dp[i][j] = dp[i][j-1]+dp[i-1][j]
-                } else if i > 0 {
-                    dp[i][j] = dp[i-1][j]
-                } else {
-                    dp[i][j] = dp[i][j-1]
-                }
-            }
-        }
-    }
-    return dp[m-1][n-1]
-}
+假设 `dp[i][j]` 表示到达网格 `(i,j)` 的路径数，先初始化 dp 第一列和第一行的所有值，然后判断。
 
+- 若 `obstacleGrid[i][j] == 1`，说明路径数为 0，`dp[i][j] = 0`；
+- 若 `obstacleGrid[i][j] == 0`，则 `dp[i][j] = dp[i - 1][j] + dp[i][j - 1]`。
+
+最后返回 `dp[m - 1][n - 1]` 即可。
 
 <!-- tabs:start -->
 
 ### **Python3**
+
 <!-- 这里可写当前语言的特殊实现逻辑 -->
 
 ```python
-
-````
+class Solution:
+    def uniquePathsWithObstacles(self, obstacleGrid: List[List[int]]) -> int:
+        m, n = len(obstacleGrid), len(obstacleGrid[0])
+        dp = [[0] * n for _ in range(m)]
+        for i in range(m):
+            if obstacleGrid[i][0] == 1:
+                break
+            dp[i][0] = 1
+        for j in range(n):
+            if obstacleGrid[0][j] == 1:
+                break
+            dp[0][j] = 1
+        for i in range(1, m):
+            for j in range(1, n):
+                if obstacleGrid[i][j] == 0:
+                    dp[i][j] = dp[i - 1][j] + dp[i][j - 1]
+        return dp[-1][-1]
+```
 
 ### **Java**
 
 <!-- 这里可写当前语言的特殊实现逻辑 -->
 
 ```java
+class Solution {
+    public int uniquePathsWithObstacles(int[][] obstacleGrid) {
+        int m = obstacleGrid.length, n = obstacleGrid[0].length;
+        int[][] dp = new int[m][n];
+        for (int i = 0; i < m && obstacleGrid[i][0] == 0; ++i) {
+            dp[i][0] = 1;
+        }
+        for (int j = 0; j < n && obstacleGrid[0][j] == 0; ++j) {
+            dp[0][j] = 1;
+        }
+        for (int i = 1; i < m; ++i) {
+            for (int j = 1; j < n; ++j) {
+                if (obstacleGrid[i][j] == 0) {
+                    dp[i][j] = dp[i - 1][j] + dp[i][j - 1];
+                }
+            }
+        }
+        return dp[m - 1][n - 1];
+    }
+}
+```
+
+### **C++**
 
+```cpp
+class Solution {
+public:
+    int uniquePathsWithObstacles(vector<vector<int>>& obstacleGrid) {
+        int m = obstacleGrid.size(), n = obstacleGrid[0].size();
+        vector<vector<int>> dp(m, vector<int>(n));
+        for (int i = 0; i < m && obstacleGrid[i][0] == 0; ++i) {
+            dp[i][0] = 1;
+        }
+        for (int j = 0; j < n && obstacleGrid[0][j] == 0; ++j) {
+            dp[0][j] = 1;
+        }
+        for (int i = 1; i < m; ++i) {
+            for (int j = 1; j < n; ++j) {
+                if (obstacleGrid[i][j] == 0) {
+                    dp[i][j] = dp[i - 1][j] + dp[i][j - 1];
+                }
+            }
+        }
+        return dp[m - 1][n - 1];
+    }
+};
+```
+
+### **Go**
+
+```go
+func uniquePathsWithObstacles(obstacleGrid [][]int) int {
+	m, n := len(obstacleGrid), len(obstacleGrid[0])
+	dp := make([][]int, m)
+	for i := 0; i < m; i++ {
+		dp[i] = make([]int, n)
+	}
+	for i := 0; i < m && obstacleGrid[i][0] == 0; i++ {
+		dp[i][0] = 1
+	}
+	for j := 0; j < n && obstacleGrid[0][j] == 0; j++ {
+		dp[0][j] = 1
+	}
+	for i := 1; i < m; i++ {
+		for j := 1; j < n; j++ {
+			if obstacleGrid[i][j] == 0 {
+				dp[i][j] = dp[i-1][j] + dp[i][j-1]
+			}
+		}
+	}
+	return dp[m-1][n-1]
+}
 ```
 
 ### **...**

solution/0000-0099/0063.Unique Paths II/README_EN.md

@@ -44,46 +44,107 @@ There are two ways to reach the bottom-right corner:
 
 ## Solutions
 
-### **Go**
-
-```go
-func uniquePathsWithObstacles(obstacleGrid [][]int) int {
-    m,n := len(obstacleGrid),len(obstacleGrid[0])
-    dp := make([][]int,m)
-    for i:=0; i < m;i++ {
-        dp[i] = make([]int,n)
-    }
-    for i := 0; i < m; i++ {
-        for j := 0; j < n; j++ {
-            if obstacleGrid[i][j] == 0 {
-                if i == 0 && j == 0 {
-                    dp[i][j] = 1
-                } else if i > 0 && j >0 {
-                    dp[i][j] = dp[i][j-1]+dp[i-1][j]
-                } else if i > 0 {
-                    dp[i][j] = dp[i-1][j]
-                } else {
-                    dp[i][j] = dp[i][j-1]
-                }
-            }
-        }
-    }
-    return dp[m-1][n-1]
-}
-```
+Dynamic programming.
 
 <!-- tabs:start -->
 
 ### **Python3**
 
 ```python
-
+class Solution:
+    def uniquePathsWithObstacles(self, obstacleGrid: List[List[int]]) -> int:
+        m, n = len(obstacleGrid), len(obstacleGrid[0])
+        dp = [[0] * n for _ in range(m)]
+        for i in range(m):
+            if obstacleGrid[i][0] == 1:
+                break
+            dp[i][0] = 1
+        for j in range(n):
+            if obstacleGrid[0][j] == 1:
+                break
+            dp[0][j] = 1
+        for i in range(1, m):
+            for j in range(1, n):
+                if obstacleGrid[i][j] == 0:
+                    dp[i][j] = dp[i - 1][j] + dp[i][j - 1]
+        return dp[-1][-1]
 ```
 
 ### **Java**
 
 ```java
+class Solution {
+    public int uniquePathsWithObstacles(int[][] obstacleGrid) {
+        int m = obstacleGrid.length, n = obstacleGrid[0].length;
+        int[][] dp = new int[m][n];
+        for (int i = 0; i < m && obstacleGrid[i][0] == 0; ++i) {
+            dp[i][0] = 1;
+        }
+        for (int j = 0; j < n && obstacleGrid[0][j] == 0; ++j) {
+            dp[0][j] = 1;
+        }
+        for (int i = 1; i < m; ++i) {
+            for (int j = 1; j < n; ++j) {
+                if (obstacleGrid[i][j] == 0) {
+                    dp[i][j] = dp[i - 1][j] + dp[i][j - 1];
+                }
+            }
+        }
+        return dp[m - 1][n - 1];
+    }
+}
+```
 
+### **C++**
+
+```cpp
+class Solution {
+public:
+    int uniquePathsWithObstacles(vector<vector<int>>& obstacleGrid) {
+        int m = obstacleGrid.size(), n = obstacleGrid[0].size();
+        vector<vector<int>> dp(m, vector<int>(n));
+        for (int i = 0; i < m && obstacleGrid[i][0] == 0; ++i) {
+            dp[i][0] = 1;
+        }
+        for (int j = 0; j < n && obstacleGrid[0][j] == 0; ++j) {
+            dp[0][j] = 1;
+        }
+        for (int i = 1; i < m; ++i) {
+            for (int j = 1; j < n; ++j) {
+                if (obstacleGrid[i][j] == 0) {
+                    dp[i][j] = dp[i - 1][j] + dp[i][j - 1];
+                }
+            }
+        }
+        return dp[m - 1][n - 1];
+    }
+};
+```
+
+### **Go**
+
+```go
+func uniquePathsWithObstacles(obstacleGrid [][]int) int {
+	m, n := len(obstacleGrid), len(obstacleGrid[0])
+	dp := make([][]int, m)
+	for i := 0; i < m; i++ {
+		dp[i] = make([]int, n)
+	}
+	for i := 0; i < m && obstacleGrid[i][0] == 0; i++ {
+		dp[i][0] = 1
+	}
+	for j := 0; j < n && obstacleGrid[0][j] == 0; j++ {
+		dp[0][j] = 1
+	}
+	for i := 1; i < m; i++ {
+		for j := 1; j < n; j++ {
+			if obstacleGrid[i][j] == 0 {
+				dp[i][j] = dp[i-1][j] + dp[i][j-1]
+			}
+		}
+	}
+	return dp[m-1][n-1]
+}
 ```
 
 ### **...**

solution/0000-0099/0063.Unique Paths II/Solution.cpp

@@ -0,0 +1,21 @@
+class Solution {
+public:
+    int uniquePathsWithObstacles(vector<vector<int>>& obstacleGrid) {
+        int m = obstacleGrid.size(), n = obstacleGrid[0].size();
+        vector<vector<int>> dp(m, vector<int>(n));
+        for (int i = 0; i < m && obstacleGrid[i][0] == 0; ++i) {
+            dp[i][0] = 1;
+        }
+        for (int j = 0; j < n && obstacleGrid[0][j] == 0; ++j) {
+            dp[0][j] = 1;
+        }
+        for (int i = 1; i < m; ++i) {
+            for (int j = 1; j < n; ++j) {
+                if (obstacleGrid[i][j] == 0) {
+                    dp[i][j] = dp[i - 1][j] + dp[i][j - 1];
+                }
+            }
+        }
+        return dp[m - 1][n - 1];
+    }
+};