动态规划——62. 不同路径&&不同路径II

62. 不同路径

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

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

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

示例 2:
输入: m = 7, n = 3
输出: 28

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

思路：动态规划 ，dp[i][j]表示到达i,j最多的路径
dp[i][j]=dp[i-1][j]+do[i][j-1];
而边界值 只有可能一条路径到达该点
所以当i,j=0时，dp[i][j]=1;

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

当然也可以利用数学知识来解决，从左上角到右下角，总共要经历的步数就是 m-1+n-1=m+n-2步，总步数中要选择m-1步往右走
即C（（m+n-2），（m-1））

不同路径II

示例 1:

输入:
[

[0,0,0],
[0,1,0],
[0,0,0]

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

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

普通动态规划思路

class Solution {
public:
    int uniquePathsWithObstacles(vector<vector<int>>& obstacleGrid) {
        int m = obstacleGrid.size(), n = obstacleGrid.at(0).size();
        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] == 0) {
                    dp[i][j] = dp[i - 1][j] + dp[i][j - 1];
                }
            }
        }
        return dp[m - 1][n - 1];
    }
};

思路：m为行数，n为列数 定义长度为列一维滚动数组，优化空间负责度，数组存储当前行每一位的情况，如果有障碍，则将该点处标记为0 没障碍的话
根据动态转移方程 f[i][j]=f[i-1][j]+f[i][j-1],由于滚动数组的优化，i自己++，f[i][j]的值直接继承了f[i-1][j]的值，所以只用加上f[i][j-1]即f[j]+=f[j-1]

class Solution {
public:
    int uniquePathsWithObstacles(vector<vector<int>>& obstacleGrid) {
        int m = obstacleGrid.size(), n = obstacleGrid.at(0).size();
        vector <int> f(n);

        f[0] = (obstacleGrid[0][0] == 0);
        for (int i = 0; i < m; ++i) {
            for (int j = 0; j < n; ++j) {
                if (obstacleGrid[i][j] == 1) {
                    f[j] = 0;
                    continue;
                }
                if (j - 1 >= 0 && obstacleGrid[i][j - 1] == 0) {
                    f[j] += f[j - 1];
                }
            }
        }

        return f.back();
    }
};