2021年算法日记：leetcode 不同路径 I（62） II （63）

自己对动态规划浅薄的理解：

动态规划的题目分为两大类，一种是求最优解类，典型问题是背包问题，另一种就是计数类，比如这里的统计方案数的问题，它们都存在一定的递推性质。前者的递推性质还有一个名字，叫做 「最优子结构」 ——即当前问题的最优解取决于子问题的最优解，后者类似，当前问题的方案数取决于子问题的方案数。所以在遇到求方案数的问题时，我们可以往动态规划的方向考虑。

不同路径I 

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

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

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

 

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/unique-paths
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

/**
 * @param {number} m
 * @param {number} n
 * @return {number}
 */
var uniquePaths = function(m, n) {
    if(m == 0 && n == 0) return 0
    // 生成一个二维m行n列数组
    var dp = Array.from(new Array(m), function() {
        return new Array(n).fill(0)
    })
    for (let i = 0; i < m; i++) {
        dp[i][0] = 1;
    }
    for (let j = 0; j < n; j++) {
        dp[0][j] = 1;
    }
    for(let i = 1; i < m; i++) {
        for(let j = 1; j < n; j++) {
            dp[i][j] = dp[i-1][j] + dp[i][j-1]
        }
    }
  return dp[m-1][n-1] 
};

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

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

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

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/unique-paths-ii
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

/**
 * @param {number[][]} obstacleGrid
 * @return {number}
 */
var uniquePathsWithObstacles = function(obstacleGrid) {
    let m = obstacleGrid.length
    let n = obstacleGrid[0].length
    if(m == 0 && n == 0) return 0
    let dp = new Array(m).fill(0).map(function(){
        return new Array(n).fill(0)
    })
    for(let i = 0; i < m;i++) {
        if(obstacleGrid[i][0] == 0) {
            dp[i][0] = 1
        } else {
            break
        }
    }
    for(let j = 0; j < n; j++) {
       if(obstacleGrid[0][j] == 0) {
           dp[0][j] =  1
       } else {
           break
       }
    }
    for(let i = 1; i < m; i++) {
        for(let j = 1; j < n; j++) {
            if(obstacleGrid[i][j] == 1) {
                dp[i][j] = 0
                continue
            } else {
                dp[i][j] = dp[i-1][j] + dp[i][j-1]
            }
        }
    }
     return dp[m-1][n-1]
};