算法题打卡day39-动态规划 | 62.不同路径、63. 不同路径 II

62. 不同路径 - 力扣（LeetCode）

状态：AC。

一步一步跟着步骤分析不难，注意一下初始化就行。时间复杂度，空间复杂度，后续可以用一维数组进行压缩优化空间复杂度（后续补充），代码如下：

class Solution {
public:
    int uniquePaths(int m, int n) {
        // 含义：dp[m][n]，表示(m, n)处的路径数
        // 转移公式：dp[m][n] = dp[m-1][n] + dp[m][n-1]
        // 初始化：dp[m+1][n+1] dp[0][i] = 0, dp[i][0] = 0, dp[0][1] = 1, dp[1][0] = 1
        // 遍历：二重循环i = 1, j = 1
        // dp[1][1] = 1 dp[1][2] = 1 dp[1][3] = 1 
        // dp[2][1] = 1 dp[2][2] = 2 dp[2][3] = 1 + 2 = 3
        // dp[3][2] = 2 + 1 = 3 dp[3][3] = dp[2][3] + dp[3][2] = 3 +3 = 6 
        vector> dp(m+1, vector(n+1, 0));
        for(int i = 1; i < m+1; ++i){
            for(int j = 1; j < n+1; ++j){
                if(i == 1 || j == 1){
                    dp[i][j] = 1;
                }
            }
        }

        for(int i = 2; i < m+1; ++i){
            for(int j = 2; j < n+1; ++j){
                dp[i][j] = dp[i-1][j] + dp[i][j-1];
            }
        }
        return dp[m][n];
    }
};

63. 不同路径 II - 力扣（LeetCode）

状态：没有AC，查看问题后AC。

这道题是在上一题的基础上加入了判断条件，需要注意的是初始化第一行第一列的时候，如果有障碍物，那么后面的就是0。时空复杂度和上一题一样，代码如下：

class Solution {
public:
    int uniquePathsWithObstacles(vector>& obstacleGrid) {
        if(obstacleGrid[0][0] == 1) return 0;
        // 和不同路径1的转移方程类似，但是要加入是否存在障碍物的判断
        int m = obstacleGrid.size(), n = obstacleGrid[0].size();
        vector> dp(m, vector(n, 0));
        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){
                dp[i][j] = dp[i-1][j] + dp[i][j-1];
                if(obstacleGrid[i][j] == 1){
                    dp[i][j] = 0;
                }
            }
        }
        return dp[m-1][n-1];
    }
};