代码随想录算法训练营day39|第九章 动态规划part02

62.不同路径 

本题大家掌握动态规划的方法就可以。 数论方法 有点非主流，很难想到。 

代码随想录

视频讲解：动态规划中如何初始化很重要！| LeetCode：62.不同路径_哔哩哔哩_bilibili

这道题其实也很简单，dp数组的意义也很容易想到，主要是dp数组初始化可能会有难度，考虑到递推公式是到达当前格子的方法=到达顶头上面的格子方法+到达左边格子的方法（因为只能往下走或往右走，故而只能从上边来或从左边来），需要初始化最左边的一列和最上边的一行为1（因为到达最上边的任意一个格子的方式只能是从开始处一直往右走，同理最左边）。

int uniquePaths(int m, int n) {
        vector<vector<int>> dp(m,vector<int>(n,0));
        for(int i=0;i<m;i++) dp[i][0]=1;
        for(int i=0;i<n;i++) dp[0][i]=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];
    }

这道题使用一维数组也可解决，因为最后只要得到最右下角的dp数组的值即可，所以可以使用一维数组，只需初始化一次即可（对应二维数组第一行的初始化，而二维行和列的初始化都为1），然后一行一行地更新（注意dp数组第一个值对应二维的最左边列是不需要更新的），每一行从左至右依次更新，更新m-1行/次，最后一个值就对应着二维数组左下角的值。整体更新完一次dp数组，就相当于得到了下一行的从上面走到这里的方法数，所以直接开始加上从左边来的方法数即可。

int uniquePaths(int m, int n) {
        vector<int> dp(n);
        for (int i = 0; i < n; i++) dp[i] = 1;
        for (int j = 1; j < m; j++) {
            for (int i = 1; i < n; i++) {
                dp[i] += dp[i - 1];
            }
        }
        return dp[n - 1];
    }

63. 不同路径 II 

https://programmercarl.com/0063.%E4%B8%8D%E5%90%8C%E8%B7%AF%E5%BE%84II.htmlhttps://programmercarl.com/0063.%E4%B8%8D%E5%90%8C%E8%B7%AF%E5%BE%84II.html

视频讲解：动态规划，这次遇到障碍了| LeetCode：63. 不同路径 II_哔哩哔哩_bilibili

这道题和上面的题也是大差不差，我是用一维数组来做的，但是其实用二维数组更接近真实情况也更好懂。如果用一维数组，主要是注意每次一遇到障碍，那么障碍本身对应的dp数组值应该为0，还要注意第二层for循环是从下标1开始的，也就是说本来默认dp数组的第一个值是不需要更新的，但因为这道题有障碍物，所以还是要更新dp[0]，遇到障碍物直接变为0即可。还有每次内层for循环更新数值的时候也要对于有障碍的地方直接更新为0。其他不变。

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

文章里面也给出了一维数组的做法，除了初始化变得复杂了一点，别的没什么差太多。

int uniquePathsWithObstacles(vector<vector<int>>& obstacleGrid) {
        if (obstacleGrid[0][0] == 1)
            return 0;
        vector<int> dp(obstacleGrid[0].size());
        for (int j = 0; j < dp.size(); ++j)
            if (obstacleGrid[0][j] == 1)
                dp[j] = 0;
            else if (j == 0)
                dp[j] = 1;
            else
                dp[j] = dp[j-1];

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