From 906293efae7e1de646593c7ae560cab726b2662f Mon Sep 17 00:00:00 2001
From: jianghongcheng <35664721+jianghongcheng@users.noreply.github.com>
Date: Thu, 1 Jun 2023 17:48:22 -0500
Subject: [PATCH] =?UTF-8?q?Update=200063.=E4=B8=8D=E5=90=8C=E8=B7=AF?=
 =?UTF-8?q?=E5=BE=84II.md?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 problems/0063.不同路径II.md | 153 ++++++++++++++++++++++----------
 1 file changed, 107 insertions(+), 46 deletions(-)

diff --git a/problems/0063.不同路径II.md b/problems/0063.不同路径II.md
index 85130ab4..ac9cae75 100644
--- a/problems/0063.不同路径II.md
+++ b/problems/0063.不同路径II.md
@@ -271,69 +271,130 @@ class Solution {
 
 
 ### Python
-
+动态规划（版本一）
 ```python
 class Solution:
-    def uniquePathsWithObstacles(self, obstacleGrid: List[List[int]]) -> int:
-        # 构造一个DP table
-        row = len(obstacleGrid)
-        col = len(obstacleGrid[0])
-        dp = [[0 for _ in range(col)] for _ in range(row)]
-        dp[0][0] = 0 if obstacleGrid[0][0] == 1 else 1
-        if dp[0][0] == 0:
-            return 0  # 如果第一个格子就是障碍，return 0
-        # 第一行
-        for i in range(1, col):
-            if obstacleGrid[0][i] == 1:
-                # 遇到障碍物时，直接退出循环，后面默认都是0
+    def uniquePathsWithObstacles(self, obstacleGrid):
+        m = len(obstacleGrid)
+        n = len(obstacleGrid[0])
+        if obstacleGrid[m - 1][n - 1] == 1 or obstacleGrid[0][0] == 1:
+            return 0
+        dp = [[0] * n for _ in range(m)]
+        for i in range(m):
+            if obstacleGrid[i][0] == 0:  # 遇到障碍物时，直接退出循环，后面默认都是0
+                dp[i][0] = 1
+            else:
                 break
-            dp[0][i] = 1
-
-        # 第一列
-        for i in range(1, row):
-            if obstacleGrid[i][0] == 1:
-                # 遇到障碍物时，直接退出循环，后面默认都是0
+        for j in range(n):
+            if obstacleGrid[0][j] == 0:
+                dp[0][j] = 1
+            else:
                 break
-            dp[i][0] = 1
-        # print(dp)
+        for i in range(1, m):
+            for j in range(1, n):
+                if obstacleGrid[i][j] == 1:
+                    continue
+                dp[i][j] = dp[i - 1][j] + dp[i][j - 1]
+        return dp[m - 1][n - 1]
 
-        for i in range(1, row):
-            for j in range(1, col):
-                if obstacleGrid[i][j] == 0:
-                    dp[i][j] = dp[i - 1][j] + dp[i][j - 1]
-        return dp[-1][-1]
 ```
+动态规划（版本二）
+```python
+class Solution:
+    def uniquePathsWithObstacles(self, obstacleGrid):
+        m = len(obstacleGrid)  # 网格的行数
+        n = len(obstacleGrid[0])  # 网格的列数
+        
+        if obstacleGrid[m - 1][n - 1] == 1 or obstacleGrid[0][0] == 1:
+            # 如果起点或终点有障碍物，直接返回0
+            return 0
+        
+        dp = [[0] * n for _ in range(m)]  # 创建一个二维列表用于存储路径数
+        
+        # 设置起点的路径数为1
+        dp[0][0] = 1 if obstacleGrid[0][0] == 0 else 0
+        
+        # 计算第一列的路径数
+        for i in range(1, m):
+            if obstacleGrid[i][0] == 0:
+                dp[i][0] = dp[i - 1][0]
+        
+        # 计算第一行的路径数
+        for j in range(1, n):
+            if obstacleGrid[0][j] == 0:
+                dp[0][j] = dp[0][j - 1]
+        
+        # 计算其他位置的路径数
+        for i in range(1, m):
+            for j in range(1, n):
+                if obstacleGrid[i][j] == 1:
+                    continue
+                dp[i][j] = dp[i - 1][j] + dp[i][j - 1]
+        
+        return dp[m - 1][n - 1]  # 返回终点的路径数
+
+
+```
+动态规划（版本三）
 
 ```python
 class Solution:
-    """
-    使用一维dp数组
-    """
+    def uniquePathsWithObstacles(self, obstacleGrid):
+        if obstacleGrid[0][0] == 1:
+            return 0
+        
+        dp = [0] * len(obstacleGrid[0])  # 创建一个一维列表用于存储路径数
+        
+        # 初始化第一行的路径数
+        for j in range(len(dp)):
+            if obstacleGrid[0][j] == 1:
+                dp[j] = 0
+            elif j == 0:
+                dp[j] = 1
+            else:
+                dp[j] = dp[j - 1]
 
-    def uniquePathsWithObstacles(self, obstacleGrid: List[List[int]]) -> int:
+        # 计算其他行的路径数
+        for i in range(1, len(obstacleGrid)):
+            for j in range(len(dp)):
+                if obstacleGrid[i][j] == 1:
+                    dp[j] = 0
+                elif j != 0:
+                    dp[j] = dp[j] + dp[j - 1]
+        
+        return dp[-1]  # 返回最后一个元素，即终点的路径数
+
+```
+动态规划（版本四）
+
+```python
+class Solution:
+    def uniquePathsWithObstacles(self, obstacleGrid):
+        if obstacleGrid[0][0] == 1:
+            return 0
+        
         m, n = len(obstacleGrid), len(obstacleGrid[0])
-
-        # 初始化dp数组
-        # 该数组缓存当前行
-        curr = [0] * n
+        
+        dp = [0] * n  # 创建一个一维列表用于存储路径数
+        
+        # 初始化第一行的路径数
         for j in range(n):
             if obstacleGrid[0][j] == 1:
                 break
-            curr[j] = 1
+            dp[j] = 1
 
-        for i in range(1, m): # 从第二行开始
-            for j in range(n): # 从第一列开始，因为第一列可能有障碍物
-                # 有障碍物处无法通行，状态就设成0
+        # 计算其他行的路径数
+        for i in range(1, m):
+            if obstacleGrid[i][0] == 1:
+                dp[0] = 0
+            for j in range(1, n):
                 if obstacleGrid[i][j] == 1:
-                    curr[j] = 0
-                elif j > 0:
-                    # 等价于
-                    # dp[i][j] = dp[i - 1][j] + dp[i][j - 1]
-                    curr[j] = curr[j] + curr[j - 1]
-                # 隐含的状态更新
-                # dp[i][0] = dp[i - 1][0]
+                    dp[j] = 0
+                else:
+                    dp[j] += dp[j - 1]
+        
+        return dp[-1]  # 返回最后一个元素，即终点的路径数
 
-        return curr[n - 1]
 ```