Day31：代码随想录算法训练营第三十一天|动态规划入门 1.力扣62 不同路径 2.力扣63 不同路径2

力扣62 不同路径

题目描述：
一个机器人位于一个 m x n 网格的左上角 （起始点在下图中标记为 “Start” ）。

机器人每次只能向下或者向右移动一步。机器人试图达到网格的右下角（在下图中标记为 “Finish” ）。

问总共有多少条不同的路径？

示例 1：

输入：m = 3, n = 7
输出：28

示例 2：

输入：m = 2, n = 3
输出：3

解释： 从左上角开始，总共有 3 条路径可以到达右下角。

向右 -> 向右 -> 向下
向右 -> 向下 -> 向右
向下 -> 向右 -> 向右

示例 3：

输入：m = 7, n = 3
输出：28

示例 4：

输入：m = 3, n = 3
输出：6

提示：

1 <= m, n <= 100
题目数据保证答案小于等于 2 * 10^9

思路：
1.递归法：
每次两个选择，要么向右，要么向左，那就形成了一个二叉树，找到叶节点时退出返回。这是大致思路，详细一点当横向步数和纵向步数都分别等于可m和n时即可以返回，但是也可能有越界的情况，此时要直接返回0，就相当于没有计数。
而在递归主体中应该要用def(i + 1, j , m , n) + def(i, j + 1, m ,n),也就是说最终走到叶子节点只有两种情况，一种时想右走到的，一种是想下走到的，也就是这个公式描述的，或者说一个时遍历左子树，一个是遍历右子树，然后把两个子树的叶子结点给加起来了。
2.数论法：
其实仔细观察就知道，无论怎么走，最终走到终点，都要横向走m-1步，纵向走n-1步，就是说一共要走m+n-2步，那我从中抽m-1步保证他横着走，那剩下的就可以纵者走，一定可以到达终点。这就转换后为了一个求组和的问题，再m+n-2中抽取m-1步有多少种情况。
3.动态规划：
第一步：
确定dp数组为dp[i][j],含义是从（0，0）到（i，j）最多有dp[i][j]条路径。
这么定义体现了动态规划的后一状态由前一状态推出，非常的像递归，递归像栈一样的先进后出，也就是不断存储状态，然后栈顶的元素就是前一个状态，栈顶元素的下一个要等栈顶元素弹出了才能弹出，和这里的后一状态由前一状态推出不谋而同。
第二步：
递推方程的确定，就是找前后状态的关联。
dp[i][j] = dp[i - 1][j] + dp[i - 1][j]，当你走到了(i - 1,j)时再下走一步就到了(i , j),同样的(i , j -1)也是这样的向右走一步，那就是说前面两个dp[i - 1][j]与dp[i - 1][j]可以直接确定dp[i][j]，这样就写出了递推方程。
第三步：
dp数组的初始化，dp[i][0] = 0和dp[j][0]=0,也就是说直接横向走的和直接纵向走的都只有一条路。
第四步：
确定遍历顺序，就是向右和向下两个for遍历。
第五步：
举例说明，没问题即可

代码如下：
递归法：
超出时间限制。

class Solution {
private:
    int dfs(int i, int j, int m, int n) {
        if (i > m || j > n) return 0; // 越界了
        if (i == m && j == n) return 1; // 找到一种方法，相当于找到了叶子节点
        return dfs(i + 1, j, m, n) + dfs(i, j + 1, m, n);
    }
public:
    int uniquePaths(int m, int n) {
        return dfs(1, 1, m, n);
    }
};

数论法：

class Solution {
public:
    int uniquePaths(int m, int n) {
        long long numerator = 1;
        int denominator = m - 1;
        int count = m - 1;
        int total = m + n - 2;
        while(count--){
            numerator *= (total--);//更新numerator阶乘
            while(denominator != 0 && numerator % denominator == 0){
                numerator /= denominator;//分子除以分母
                denominator--;//逐渐减少分母，也就是分母阶乘的下一个
            }
        }
        return numerator;
    }
};

动态规划：

class Solution {
public:
    int uniquePaths(int m, int n) {
        vector<vector<int>> dp(m, vector<int>(n, 0));//分配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];//小细节，是从（0，0）开始的
    }
};

力扣63 不同路径2

题目描述：
一个机器人位于一个 m x n 网格的左上角 （起始点在下图中标记为“Start” ）。

机器人每次只能向下或者向右移动一步。机器人试图达到网格的右下角（在下图中标记为“Finish”）。

现在考虑网格中有障碍物。那么从左上角到右下角将会有多少条不同的路径？

网格中的障碍物和空位置分别用 1 和 0 来表示。

示例 1：

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

示例 2：

输入：obstacleGrid = [[0,1],[0,0]]
输出：1

提示：

m == obstacleGrid.length
n == obstacleGrid[i].length
1 <= m, n <= 100
obstacleGrid[i][j] 为 0 或 1

思路：
遇上一题思路一致，主要是在动态规划的第2步、第3步和第4步有不一样了。
在初始化dp数组时要考虑到障碍物，也就是说一旦遇到了障碍物了，就是说在一个方向上遇到了障碍物，那就要不能考虑这条路。
在遍历的时候要注意遇到障碍的情况，只有当没遇到障碍时才可以通过，有障碍的话就要跳过。

代码如下：

class Solution {
public:
    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) //如果在起点或终点出现了障碍，直接返回0
            return 0;
        vector<vector<int>> dp(m, vector<int>(n, 0));
        //建立dp数组
        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];
    }
};