【动态规划】求矩阵自顶向下最短路径和

比如：

输入： [
[1],
[4, 2],
[3, 6, 7],
[6, 7, 8, 9],
[1, 2, 5, 6, 7]
]
输出：13

从暴力递归=>记忆化搜索=>严格表依赖

1. 暴力递归

function main(matrix) {
    return process(matrix, 0, 0)
}
function process(m, i, j) {// i当前的位置
    // 已经达到最下
    if (i === m.length - 1) {
        return m[i][j]
    }
    if (j == 0) {
        return m[i][j] + Math.min(process(m, i + 1, j), process(m, i + 1, j + 1))
    }
    let p1 = process(m, i + 1, j - 1)
    let p2 = process(m, i + 1, j)
    let p3 = process(m, i + 1, j + 1)
    return Math.min(p1, Math.min(p2, p3)) + m[i][j]
}
console.log(main([[1], [4, 2], [3, 6, 7], [6, 7, 8, 9], [1, 2, 5, 6, 7]]))

2. 记忆化搜索

// 记忆化搜索
function main1(matrix) {
    let n = matrix.length
    let m = matrix[n - 1].length
    let dp = [...Array(n)].map(v => [...Array(m)].fill(-1));
    return process1(matrix, 0, 0, dp)
}
function process1(m, i, j, dp) {
    if (dp[i][j] !== -1) {
        return dp[i][j]
    }
    if (i === m.length - 1) {
        dp[i][j] = m[i][j]
    } else if (j == 0) {
        dp[i][j] = m[i][j] + Math.min(process(m, i + 1, j), process(m, i + 1, j + 1))
    } else {
        let p1 = process(m, i + 1, j - 1)
        let p2 = process(m, i + 1, j)
        let p3 = process(m, i + 1, j + 1)
        dp[i][i] = Math.min(p1, Math.min(p2, p3)) + m[i][j]
    }
    return dp[i][j]
}
console.log(main1([[1], [4, 2], [3, 6, 7], [6, 7, 8, 9], [1, 2, 5, 6, 7]]))

3. 严格表依赖

// 严格表依赖的
function main2(matrix) {
    let n = matrix.length
    let m = matrix[n - 1].length
    let dp = [...Array(n)].map(v => [...Array(m)].fill(0));
    // 最后一行
    for (let i = 0; i < m; i++) {
        dp[n - 1][i] = matrix[n - 1][i]
    }
    for (let i = n - 2; i >= 0; i--) {
        for (let j = 0; j < i + 1; j++) {
            if (j - 1 >= 0) {
                dp[i][j] = matrix[i][j] + Math.min(dp[i + 1][j - 1], Math.min(dp[i + 1][j], dp[i + 1][j + 1]))
            } else {
                dp[i][j] = matrix[i][j] + Math.min(dp[i + 1][j], Math.min(dp[i + 1][j + 1]))
            }
        }
    }
    return dp[0][0]
}
console.log(main2([[1], [4, 2], [3, 6, 7], [6, 7, 8, 9], [1, 2, 5, 6, 7]]))