不同路径相关问题【C++】【动态规划】

62.不同路径题目链接

不同路径
一个机器人位于一个 m x n 网格的左上角 （起始点在下图中标记为 “Start” ）。
机器人每次只能向下或者向右移动一步。机器人试图达到网格的右下角（在下图中标记为 “Finish” ）。
问总共有多少条不同的路径？
示例 1：

输入：m = 3, n = 7
输出：28
示例 2：
输入：m = 3, n = 2
输出：3
解释：
从左上角开始，总共有 3 条路径可以到达右下角。

1. 向右 -> 向下 -> 向下
2. 向下 -> 向下 -> 向右
3. 向下 -> 向右 -> 向下

示例 3：
输入：m = 7, n = 3
输出：28
示例 4：
输入：m = 3, n = 3
输出：6
提示：
1 <= m, n <= 100
题目数据保证答案小于等于 2 * 10⁹

思路

题目要求只能向右和向下移动，所以坐标(i,j)只能由(i-1,j)或者(i,j-1)得到，满足：当前状态由以前状态有关的特性，可以考虑动态规划方法，使用动态规划的固定步骤：

1. 确定dp数组含义：
   本题是求到一个坐标的路径数，所以dp数组需要两维来表示。dp[i][j]:从(0,0)到(i,j)的路径数

vector<vector<int>> dp(m, vector<int>(n, 0));  //m为行数，n为列数

2. 确定递推公式：
   dp[i][j]==上面一格的路径数+左边一格的路径数

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

3. 初始化
   初始化由递推公式确定，每个值由上边和左边决定，所以第一行和第一列需要初始化。

for (int i = 0; i < m; i++){   //初始化第一列和第一行
    dp[i][0] = 1;
}
for (int j = 0; j < n; j++){
    dp[0][j] = 1;
}

4. 确定遍历顺序：
   同样由递推公式确定，从小下标到大下标，所以需要从小到大遍历：
   由于本题dp数组是二维的，存在一个问题：先遍历行还是列？本题无影响，但有些二维动态规划有影响，比如背包问题等，对于二维dp数组的遍历顺序需要认真考虑。

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]; 
    }
}

5. 打印dp数组
   出错时，通过dp数组排查问题所在。

62.不同路径完整代码

class Solution {
public:
    int uniquePaths(int m, int n) {
        vector<vector<int>> dp(m, vector<int>(n, 0));  //定义dp数组的含义:dp[i][j]表示路径数
        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];
    }
};

63. 不同路径 II

题目链接
一个机器人位于一个 m x n 网格的左上角 （起始点在下图中标记为 “Start” ）。
机器人每次只能向下或者向右移动一步。机器人试图达到网格的右下角（在下图中标记为 “Finish”）。
现在考虑网格中有障碍物。那么从左上角到右下角将会有多少条不同的路径？
网格中的障碍物和空位置分别用 1 和 0 来表示。
示例 1：

输入：obstacleGrid = [[0,0,0],[0,1,0],[0,0,0]]
输出：2
解释：3x3 网格的正中间有一个障碍物。
从左上角到右下角一共有 2 条不同的路径：

1. 向右 -> 向右 -> 向下 -> 向下
2. 向下 -> 向下 -> 向右 -> 向右

示例 2：

输入：obstacleGrid = [[0,1],[0,0]]
输出：1
提示：
m == obstacleGrid.length
n == obstacleGrid[i].length
1 <= m, n <= 100
obstacleGrid[i][j] 为 0 或 1

思路

不同于第一题，本题加入了障碍，但是(i,j)的路径数依旧由(i-1,j)和(i,j-1)有关，所以依旧考虑使用动态规划方法，只是需要修改递归公式等内容。

1. 确定dp数组含义：
   dp[i][j]:从(0,0)到(i,j)的路径数

vector<vector<int>> dp(m, vector<int> (n,0)); //定义dp，m和n分别表示行数和列数

2. 确定递推公式：
   只对无障碍的坐标进行运算：

if (obstacleGrid[i][j] == 0){     //递归方程
    dp[i][j] = dp[i - 1][j] + dp[i][j - 1];
}

3. 初始化
   首先不能到达的坐标（有障碍物）初始化为0，然后分别初始化第一列和第一行为1，但有障碍物及后面都保留0.

for (int i = 0; i < m && obstacleGrid[i][0] != 1; i++){  //初始化第一列
    dp[i][0] = 1;
}
for (int j = 0; j < n && obstacleGrid[0][j] != 1; j++){  //初始化第一行
    dp[0][j] = 1;
}

4. 确定递推顺序
   先遍历行或者列都行。

for (int i = 1; i < m; i++){        //遍历
    for (int j = 1; j < n; j++){
        //递推公式
    }
}

完整代码

class Solution {
public:
    int uniquePathsWithObstacles(vector<vector<int>>& obstacleGrid) {
        int m = obstacleGrid.size();
        int n = obstacleGrid[0].size();
        if (obstacleGrid[0][0] == 1 || obstacleGrid[m - 1][n - 1] == 1){  //边界判断
            return 0;
        }
        vector<vector<int>> dp(m, vector<int> (n,0)); //定义dp
        for (int i = 0; i < m && obstacleGrid[i][0] != 1; i++){  //初始化dp
            dp[i][0] = 1;
        }
        for (int j = 0; j < n && obstacleGrid[0][j] != 1; j++){
            dp[0][j] = 1;
        }
        for (int i = 1; i < m; i++){        //遍历
            for (int j = 1; j < n; j++){
                if (obstacleGrid[i][j] == 0){     //递归方程
                    dp[i][j] = dp[i - 1][j] + dp[i][j - 1];
                }
            }
        }
        return dp[m - 1][n - 1];
    }
};