动态规划及letCode相关题目(JavaScript 解法)

1. letCode62 不同路径

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

/**
 * @param {number} m
 * @param {number} n
 * @return {number}
 */
var uniquePaths = function(m, n) {
    var dp = new Array(n)
    for(let i = 0; i < n; i++){
        dp[i] = []
    }
    // 初始化
    dp[0][0]= 1
    for(let i = 1; i < m; i++){
        dp[0][i] = 1
    }
    for(let i = 1; i < n; i++){
        dp[i][0] = 1
    }
    // 遍历
    for(let i = 1; i < n; i++){
        for(let x = 1; x < m; x++){
            dp[i][x] = dp[i][x-1] + dp[i-1][x]
        }
    }
    return dp[n-1][m-1]
};

// 以下对上述代码进行了简化
/**
 * @param {number} m
 * @param {number} n
 * @return {number}
 */
var uniquePaths = function(m, n) {
    var dp = new Array(n)
    for(let i = 0; i < n; i++){
        dp[i] = []
    }
    for(let i = 0; i < n; i++){
        for(let x = 0; x < m; x++){
            dp[i][x] = i==0 ? 1: x== 0 ? 1 : dp[i][x-1] + dp[i-1][x]
        }
    }
    return dp[n-1][m-1]
};

2. letCode63 不同路径 Ⅱ

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

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

3. letCode64 最小路径和

题目：给定一个包含非负整数的 m x n 网格 grid ，请找出一条从左上角到右下角的路径，使得路径上的数字总和为最小。
说明：每次只能向下或者向右移动一步。

/**
 * @param {number[][]} grid
 * @return {number}
 */
var minPathSum = function(grid) {
    var m = grid.length, n = grid[0].length;
    var dp = new Array(n)
    for(let i = 0; i < n; i++){
        dp[i] = []
    }
    for(let i = 0; i < n; i++){
        for(let x = 0; x < m; x++){
            if(i == 0 && x != 0){
                dp[i][x] = dp[i][x-1] + grid[x][i]
            } else if(i != 0 && x == 0) {
                dp[i][x] = dp[i-1][x] + grid[x][i]
            } else if(i == 0 && x==0) {
                dp[i][x] = grid[0][0]
            } else {
                dp[i][x] = Math.min(dp[i-1][x], dp[i][x-1]) + grid[x][i]
            }
        }
    }
    return dp[n-1][m-1]
};

4. letCode91 解码方法

题目： 一条包含字母 A-Z 的消息通过以下映射进行了 编码 ：

‘A’ -> 1
‘B’ -> 2
…
‘Z’ -> 26
要 解码 已编码的消息，所有数字必须基于上述映射的方法，反向映射回字母（可能有多种方法）。例如，“11106” 可以映射为：
“AAJF” ，将消息分组为 (1 1 10 6)
“KJF” ，将消息分组为 (11 10 6)
注意，消息不能分组为 (1 11 06) ，因为 “06” 不能映射为 “F” ，这是由于 “6” 和 “06” 在映射中并不等价。
给你一个只含数字的 非空 字符串 s ，请计算并返回 解码 方法的 总数 。
题目数据保证答案肯定是一个 32 位 的整数。

/**
 * @param {string} s
 * @return {number}
 */
var numDecodings = function(s) {
    if(s[0] == "0" || s.length == 0) return 0
    var arr = s.split('')
    var i = 1
    while( i < arr.length){
        if(arr[i] == '0'){
            arr[i-1] = arr[i-1] + arr[i]
            var num  = Number(arr[i-1])
            if(num > 26 || num == 0) return 0
            arr.splice(i, 1)
        } else {
            i++
        }
    }
    if(arr.length == 1) return 1
    var dp = []
    dp[0] = 1
    dp[1] = Number(arr[0] + arr[1]) > 26 ? 1 : 2
    for(var j = 2 ; j < arr.length; j++){
        var num = Number(arr[j - 1] + arr[j])
        if(num > 26){
            dp[j] = dp[j - 1]
        } else {
            dp[j] = dp[j-1] + dp[j-2]
        }
    }
    return dp.pop()
};

5. letCode97 交错字母

题目：给定三个字符串 s1、s2、s3，请你帮忙验证 s3 是否是由 s1 和 s2 交错 组成的。
两个字符串 s 和 t 交错 的定义与过程如下，其中每个字符串都会被分割成若干 非空 子字符串：
s = s1 + s2 + … + sn
t = t1 + t2 + … + tm
|n - m| <= 1
交错 是 s1 + t1 + s2 + t2 + s3 + t3 + … 或者 t1 + s1 + t2 + s2 + t3 + s3 + …
提示：a + b 意味着字符串 a 和 b 连接。

/**
 * @param {string} s1
 * @param {string} s2
 * @param {string} s3
 * @return {boolean}
 */
var isInterleave = function(s1, s2, s3) {
    var dp = []
    var m = s1.length, n = s2.length
    if(m + n != s3.length) return false
    for(var i = 0; i <= m; i++){
        dp[i] = []
        dp[i][0] = i == 0 ? true : dp[i-1][0] && (s1[i-1] == s3[i-1]) 
    }
    for(var j = 1; j <= n; j++){
        dp[0][j] = dp[0][j-1] && (s2[j-1] == s3[j-1])
    }
    for(var x = 1; x <= m; x++){
        for(var y = 1; y <= n; y++){
            dp[x][y] = (dp[x-1][y] && s1[x-1] == s3[x-1+y]) || (dp[x][y-1] && s2[y-1] == s3[x-1+y])
        }
    }
    return dp[m][n]
};

6. letCode120 三角形最小路径和

题目：给定一个三角形 triangle ，找出自顶向下的最小路径和。
每一步只能移动到下一行中相邻的结点上。相邻的结点 在这里指的是 下标 与 上一层结点下标 相同或者等于 上一层结点下标 + 1 的两个结点。也就是说，如果正位于当前行的下标 i ，那么下一步可以移动到下一行的下标 i 或 i + 1 。

/**
 * @param {number[][]} triangle
 * @return {number}
 */
var minimumTotal = function(triangle) {
    var dp = []
    var len  = triangle.length
    for(let i = 0; i < len; i++){
        dp[i] = []
        dp[i][0] = i == 0 ? triangle[0][0] : dp[i-1][0] + triangle[i][0]
    }
    for(let i = 1; i < len; i++){
        for(let j = 1; j <= i; j++){
            if(dp[i-1][j] || dp[i-1][j] == 0) {
                dp[i][j] = dp[i-1][j] >= dp[i-1][j-1] ? dp[i-1][j-1] + triangle[i][j] : dp[i-1][j] + triangle[i][j]
            } else {
                dp[i][j] = dp[i-1][j-1] + triangle[i][j]
            }
        }
    }
    return dp[len-1].sort((a, b) => a-b)[0]
};