【LeetCode】931、289

931. 下降路径最小和

function minFallingPathSum(matrix: number[][]): number {
    
    
    let n = matrix.length
    if (n == 1) return matrix[0][0]
    for (let i1 = 1; i1 < n; i1++) {
    
    
        for (let i2 = 0; i2 < n; i2++) {
    
    
            if (i2 === 0) {
    
    
                matrix[i1][i2] = matrix[i1][i2] + Math.min(matrix[i1 - 1][i2], matrix[i1 - 1][i2 + 1])
            } else if (i2 === n - 1) {
    
    
                matrix[i1][i2] = matrix[i1][i2] + Math.min(matrix[i1 - 1][i2 - 1], matrix[i1 - 1][i2])
            } else {
    
    
                matrix[i1][i2] = matrix[i1][i2] + Math.min(matrix[i1 - 1][i2 - 1], Math.min(matrix[i1 - 1][i2], matrix[i1 - 1][i2 + 1]))
            }
        }
        if (i1 == n - 1) {
    
    
            matrix[i1].sort((a, b) => a - b)
            return matrix[i1][0]
        }
    }
    return 0
};

1289. 下降路径最小和 II

function minFallingPathSum(grid: number[][]): number {
    
    
    const len: number = grid.length
    // 特殊情况处理
    if (len == 1) return grid[0][0]
    if (len == 2) {
    
    
        return Math.min(grid[0][1], grid[1][0])
    }
    for (let i1 = 1; i1 < len; i1++) {
    
    
        // 获取上一行最小值及第二小值的下标
        let min1 = grid[i1 - 1][0] > grid[i1 - 1][1] ? grid[i1 - 1][1] : grid[i1 - 1][0]
        let sub1 = grid[i1 - 1][0] > grid[i1 - 1][1] ? 1 : 0
        let min2 = grid[i1 - 1][0] > grid[i1 - 1][1] ? grid[i1 - 1][0] : grid[i1 - 1][1]
        let sub2 = grid[i1 - 1][0] > grid[i1 - 1][1] ? 0 : 1
        for (let i = 2; i < len; i++) {
    
    
            if (grid[i1 - 1][i] < min2) {
    
    
                if (grid[i1 - 1][i] < min1) {
    
    
                    // 小于2个
                    min2 = min1
                    sub2 = sub1
                    min1 = grid[i1 - 1][i]
                    sub1 = i
                } else {
    
    
                    // 小于1个
                    min2 = grid[i1 - 1][i]
                    sub2 = i
                }
            }
        }
        // 当前行赋值
        for (let i2 = 0; i2 < len; i2++) {
    
    
            if (i2 == sub1) {
    
    
                // 当前为最小值
                grid[i1][i2] = grid[i1][i2] + grid[i1 - 1][sub2]
            } else {
    
    
                // 当前不为最小值
                grid[i1][i2] = grid[i1][i2] + grid[i1 - 1][sub1]
            }
        }
        if (i1 == len - 1) {
    
    
            grid[i1].sort((a, b) => a - b)
            return grid[i1][0]
        }
    }
    return 0
};