Cover image for Interview Classic 150 Questions P63 Unique Paths II

Interview Classic 150 Questions P63 Unique Paths II

(Updated: )
algorithm
, ,
Timeline

timeline

2025-12-13

init

dynamic programming

Problem:

P63 Unique Paths II

https://leetcode.cn/problems/unique-paths-ii/description/?envType=study-plan-v2&envId=top-interview-150

Note that the special case when mn1 should be considered.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
#include <vector>
using std::vector;

class Solution {
    public:
        int uniquePathsWithObstacles(vector<vector<int> > &obstacleGrid)
        {
                int i, j, m = obstacleGrid.size(), n = obstacleGrid[0].size();
                if (m == 1 && n == 1) {
                        if (obstacleGrid[0][0] == 1) {
                                return 0;
                        }else{
                                return 1;
                        }
                }
                // dp[i][j] represents the number of different paths to reach grid[i][j]
                vector<vector<int> > dp(m, vector<int>(n, 0));

                dp[0][0] = 1;
                for (i = 1; i < m; i++) {
                        if (obstacleGrid[i - 1][0] != 1 &&
                            obstacleGrid[i][0] != 1) {
                                dp[i][0] = 1;
                        } else {
                                break;
                        }
                }

                for (j = 1; j < n; j++) {
                        if (obstacleGrid[0][j - 1] != 1 &&
                            obstacleGrid[0][j] != 1) {
                                dp[0][j] = 1;
                        } else {
                                break;
                        }
                }

                for (i = 1; i < m; i++) {
                        for (j = 1; j < n; j++) {
                                if (obstacleGrid[i][j] == 1) {
                                        continue;
                                }
                                if (obstacleGrid[i - 1][j] == 1 &&
                                    obstacleGrid[i][j - 1] == 1) {
                                        continue; // set default as 0
                                } else if (obstacleGrid[i - 1][j] == 1 &&
                                           obstacleGrid[i][j - 1] == 0) {
                                        dp[i][j] = dp[i][j - 1];
                                } else if (obstacleGrid[i - 1][j] == 0 &&
                                           obstacleGrid[i][j - 1] == 1) {
                                        dp[i][j] = dp[i - 1][j];
                                } else {
                                        dp[i][j] = dp[i - 1][j] + dp[i][j - 1];
                                }
                        }
                }
                return dp[m - 1][n - 1];
        }
};