day42-动态规划2

•  62.不同路径 

•  63. 不同路径 II 

第一题：不同路径

第一种方法可以用二叉树的深度搜索，求叶子节点的数量

低估函数是dfs(int i,int j, int m,int n)

终止条件是if(i>m || j>n)return 0;   if(i==m && j==n) return 1;

单层递归逻辑是 dfs(i+1,j,m,n) +dfs(i,j+1,m,n)  计算往下+往右

第二种方法：动态规划五部曲

（1）确定二维dp数组以及下标含义

dp[i][j]:表示从(0,0)出发，到（i,j）有dp[i][j]条路径

（2）确定递推公式

到(i,j)可以有两种方式，例如从(i-1,j)往下一步，或者从(i,j-1)往右走一步，

所以dp[i][j]=dp[i-1][j]+dp[i][j-1]

（3）dp数组的初始化

dp[i][0]一定是1，因为第一列的数只能从上一级往下走一步，所以只有一种方式

同理，dp[0][j]也为1，只往右走

初始化代码：

for(int i=0;i<m;i++) dp[i][0]=1

for(int j=0;j<n;j++) dp[0][j]=1

（4）确定遍历顺序

dp[i][j]来自其上方和左方，那么从左到右一层一层的遍历

（5）举例推导

dp[i][j]=dp[i-1][j]+dp[i][j-1]

vector<vector<int>> dp(m,vector<int>(n,0));//定义一个二维数组

第二题：不同路径2

相比于第一题，多了障碍物

动态规划五部曲

（1）确定dp数组及下标含义

肯定还是dp[i][j]，表示到达（i，j）的路径数

（2）确定递推公式

跟上一题不同，如果（i,j）上有障碍物，首先dp[i][j]这点肯定是无法到达的，即dp[i][j]=0;

然后如果是第一行和第一列中有障碍物，那么他的右边或者下边肯定都无法到达。没有障碍时，递推和上题一样

所以递推公式：

if(obstacleGrid[i][j]==0){

dp[i][j]=dp[i-1][j]+dp[i][j-1];

}

（3）确定数组初始化

vector<vecto<int>> dp(m,vector<int>(n,0));

for(int i=0;i<m &&obstacleGrid[i][0]==0;i++) dp[i][0]=1;

for(int j=0;j<n &7 obstacleGrid[0][j]==0;j++) dp[0][j]=1;

//就是只对障碍前的格子赋值，后面的不管

（4）确定遍历顺序

从左到右，从上到下一层一层的遍历，如果该点是障碍，就跳过该点继续遍历

（5）举例推导dp数组

代码：

int uniquePathsWithObstacles(vector<vector<int>>& obstacleGrid) {
        int m=obstacleGrid.size();
        int n=obstacleGrid[0].size();
        if(obstacleGrid[m-1][n-1]==1 || obstacleGrid[0][0]==1) //如果在起点或者终点出现了障碍物，直接返回
        return 0;
        
        vector<vector<int>> dp(m,vector<int>(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++)
            {
                if(obstacleGrid[i][j]==1) continue;
                dp[i][j]=dp[i-1][j]+dp[i][j-1];
            }
        }
        return dp[m-1][n-1];

    }

总结：对于动态规划的不同路径问题，可能是不太熟悉，上来的思路是从前到后，站在起点的位置思考怎么往下跳，但是正确的思路应该是从后往前思考，站在终点上看有哪些方法可以到达它，二叉树为前者，动态规划为后者。