|
48 | 48 | <li><code>obstacleGrid[i][j]</code> 为 <code>0</code> 或 <code>1</code></li> |
49 | 49 | </ul> |
50 | 50 |
|
51 | | - |
52 | 51 | ## 解法 |
53 | 52 |
|
54 | 53 | <!-- 这里可写通用的实现逻辑 --> |
55 | 54 |
|
56 | | -### **Go** |
| 55 | +动态规划。 |
57 | 56 |
|
58 | | -````go |
59 | | -func uniquePathsWithObstacles(obstacleGrid [][]int) int { |
60 | | - m,n := len(obstacleGrid),len(obstacleGrid[0]) |
61 | | - dp := make([][]int,m) |
62 | | - for i:=0; i < m;i++ { |
63 | | - dp[i] = make([]int,n) |
64 | | - } |
65 | | - for i := 0; i < m; i++ { |
66 | | - for j := 0; j < n; j++ { |
67 | | - if obstacleGrid[i][j] == 0 { |
68 | | - if i == 0 && j == 0 { |
69 | | - dp[i][j] = 1 |
70 | | - } else if i > 0 && j >0 { |
71 | | - dp[i][j] = dp[i][j-1]+dp[i-1][j] |
72 | | - } else if i > 0 { |
73 | | - dp[i][j] = dp[i-1][j] |
74 | | - } else { |
75 | | - dp[i][j] = dp[i][j-1] |
76 | | - } |
77 | | - } |
78 | | - } |
79 | | - } |
80 | | - return dp[m-1][n-1] |
81 | | -} |
| 57 | +假设 `dp[i][j]` 表示到达网格 `(i,j)` 的路径数,先初始化 dp 第一列和第一行的所有值,然后判断。 |
82 | 58 |
|
| 59 | +- 若 `obstacleGrid[i][j] == 1`,说明路径数为 0,`dp[i][j] = 0`; |
| 60 | +- 若 `obstacleGrid[i][j] == 0`,则 `dp[i][j] = dp[i - 1][j] + dp[i][j - 1]`。 |
| 61 | + |
| 62 | +最后返回 `dp[m - 1][n - 1]` 即可。 |
83 | 63 |
|
84 | 64 | <!-- tabs:start --> |
85 | 65 |
|
86 | 66 | ### **Python3** |
| 67 | + |
87 | 68 | <!-- 这里可写当前语言的特殊实现逻辑 --> |
88 | 69 |
|
89 | 70 | ```python |
90 | | - |
91 | | -```` |
| 71 | +class Solution: |
| 72 | + def uniquePathsWithObstacles(self, obstacleGrid: List[List[int]]) -> int: |
| 73 | + m, n = len(obstacleGrid), len(obstacleGrid[0]) |
| 74 | + dp = [[0] * n for _ in range(m)] |
| 75 | + for i in range(m): |
| 76 | + if obstacleGrid[i][0] == 1: |
| 77 | + break |
| 78 | + dp[i][0] = 1 |
| 79 | + for j in range(n): |
| 80 | + if obstacleGrid[0][j] == 1: |
| 81 | + break |
| 82 | + dp[0][j] = 1 |
| 83 | + for i in range(1, m): |
| 84 | + for j in range(1, n): |
| 85 | + if obstacleGrid[i][j] == 0: |
| 86 | + dp[i][j] = dp[i - 1][j] + dp[i][j - 1] |
| 87 | + return dp[-1][-1] |
| 88 | +``` |
92 | 89 |
|
93 | 90 | ### **Java** |
94 | 91 |
|
95 | 92 | <!-- 这里可写当前语言的特殊实现逻辑 --> |
96 | 93 |
|
97 | 94 | ```java |
| 95 | +class Solution { |
| 96 | + public int uniquePathsWithObstacles(int[][] obstacleGrid) { |
| 97 | + int m = obstacleGrid.length, n = obstacleGrid[0].length; |
| 98 | + int[][] dp = new int[m][n]; |
| 99 | + for (int i = 0; i < m && obstacleGrid[i][0] == 0; ++i) { |
| 100 | + dp[i][0] = 1; |
| 101 | + } |
| 102 | + for (int j = 0; j < n && obstacleGrid[0][j] == 0; ++j) { |
| 103 | + dp[0][j] = 1; |
| 104 | + } |
| 105 | + for (int i = 1; i < m; ++i) { |
| 106 | + for (int j = 1; j < n; ++j) { |
| 107 | + if (obstacleGrid[i][j] == 0) { |
| 108 | + dp[i][j] = dp[i - 1][j] + dp[i][j - 1]; |
| 109 | + } |
| 110 | + } |
| 111 | + } |
| 112 | + return dp[m - 1][n - 1]; |
| 113 | + } |
| 114 | +} |
| 115 | +``` |
| 116 | + |
| 117 | +### **C++** |
98 | 118 |
|
| 119 | +```cpp |
| 120 | +class Solution { |
| 121 | +public: |
| 122 | + int uniquePathsWithObstacles(vector<vector<int>>& obstacleGrid) { |
| 123 | + int m = obstacleGrid.size(), n = obstacleGrid[0].size(); |
| 124 | + vector<vector<int>> dp(m, vector<int>(n)); |
| 125 | + for (int i = 0; i < m && obstacleGrid[i][0] == 0; ++i) { |
| 126 | + dp[i][0] = 1; |
| 127 | + } |
| 128 | + for (int j = 0; j < n && obstacleGrid[0][j] == 0; ++j) { |
| 129 | + dp[0][j] = 1; |
| 130 | + } |
| 131 | + for (int i = 1; i < m; ++i) { |
| 132 | + for (int j = 1; j < n; ++j) { |
| 133 | + if (obstacleGrid[i][j] == 0) { |
| 134 | + dp[i][j] = dp[i - 1][j] + dp[i][j - 1]; |
| 135 | + } |
| 136 | + } |
| 137 | + } |
| 138 | + return dp[m - 1][n - 1]; |
| 139 | + } |
| 140 | +}; |
| 141 | +``` |
| 142 | + |
| 143 | +### **Go** |
| 144 | + |
| 145 | +```go |
| 146 | +func uniquePathsWithObstacles(obstacleGrid [][]int) int { |
| 147 | + m, n := len(obstacleGrid), len(obstacleGrid[0]) |
| 148 | + dp := make([][]int, m) |
| 149 | + for i := 0; i < m; i++ { |
| 150 | + dp[i] = make([]int, n) |
| 151 | + } |
| 152 | + for i := 0; i < m && obstacleGrid[i][0] == 0; i++ { |
| 153 | + dp[i][0] = 1 |
| 154 | + } |
| 155 | + for j := 0; j < n && obstacleGrid[0][j] == 0; j++ { |
| 156 | + dp[0][j] = 1 |
| 157 | + } |
| 158 | + for i := 1; i < m; i++ { |
| 159 | + for j := 1; j < n; j++ { |
| 160 | + if obstacleGrid[i][j] == 0 { |
| 161 | + dp[i][j] = dp[i-1][j] + dp[i][j-1] |
| 162 | + } |
| 163 | + } |
| 164 | + } |
| 165 | + return dp[m-1][n-1] |
| 166 | +} |
99 | 167 | ``` |
100 | 168 |
|
101 | 169 | ### **...** |
|
0 commit comments