代码随想录算法训练营第三十九天 | 62.不同路径，63. 不同路径 II

目录

62.不同路径

63. 不同路径 II

---

62.不同路径

题目链接：62. 不同路径

很明显的动态规划题目

（1）dp[ i ][ j ] 表示到达第 i 行 j 列共有多少种不同的路径；

（2）dp[ i ][ j ] = dp[ i - 1 ][ j ] + dp[ i ][ j - 1 ]；

（3）dp[ 0 ][ j ] = dp[ i ][ 0 ] = 1；

（4）i 从 1 到 m 遍历，j 从 1 到 n 遍历；

class Solution {
public:
    int uniquePaths(int m, int n) {
        int dp[m][n];
        for(int i = 0; i < m; ++i){
            dp[i][0] = 1;
        }
        for(int j = 0; j < n; ++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];
            }
        }
        return dp[m-1][n-1];
    }
};

分析一下不难发现，可以将数组压缩到二维，运用滚动压缩的思想：

class Solution {
public:
    int uniquePaths(int m, int n) {
        int dp[n];
        for(int j = 0; j < n; ++j){
            dp[j] = 1;
        }
        for(int i = 1; i < m; ++i){
            for(int j = 1; j < n; ++j){
                dp[j] += dp[j-1];
            }
        }
        return dp[n-1];
    }
};

63. 不同路径 II

题目链接：63. 不同路径 II

比较上一题，图中间多了障碍物，也就是说障碍物的右边和下边的格子不能从经由障碍的路径到达，如果障碍物在边路，则边路更远的地方则无法到达；此外，其余逻辑不变。

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

同样可以压缩数组维数，有点难想，但是可以理解：

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

        for(int i = 1; i < m; ++i){
            for(int j = 0; j < n; ++j){
                if(obstacleGrid[i][j] == 1) dp[j] = 0;
                else if(j != 0)    dp[j] += dp[j-1];
            }
        }
        return dp[n-1];
    }
};