数据结构与算法之Leetcode-931. 下降路径最小和 - 力扣（动态规划）

最新推荐文章于 2023-07-13 16:30:34 发布

Three_ST

最新推荐文章于 2023-07-13 16:30:34 发布

阅读量258

点赞数

分类专栏： leetcode 笔记计算机基础文章标签： leetcode 动态规划算法

本文链接：https://blog.csdn.net/qq_25482087/article/details/128322132

版权

计算机基础同时被 3 个专栏收录

50 篇文章 0 订阅

订阅专栏

leetcode

49 篇文章 0 订阅

订阅专栏

笔记

34 篇文章 0 订阅

订阅专栏

931. 下降路径最小和 - 力扣（LeetCode）

找出最短路径
- 假定上一层的位置为[row,col]
- 下一层的位置要满足以下条件：
  - [row+1,col-1],[row+1,col],[row+1,col+1]
- 使用动态规划计算每一层的路径和，从底往上
  - 最左边
  - 最右边
  - dp[i][j]

class Solution {
    int MAX = Integer.MAX_VALUE;
    public int minFallingPathSum(int[][] mat) {
        int n = mat.length;
        int[][] f = new int[n][n];
        // 初始化：对于首行而言，每个位置的「最小成本」就是其「矩阵值」
        for (int i = 0; i < n; i++) f[0][i] = mat[0][i];
        // 从第二行开始，根据题目给定的条件进行转移
        for (int i = 1; i < n; i++) {
            for (int j = 0; j < n; j++) {
                int val = mat[i][j];
                f[i][j] = f[i - 1][j] + val;
                if (j - 1 >= 0) f[i][j] = Math.min(f[i][j], f[i-1][j-1] + val);
                if (j + 1 <  n) f[i][j] = Math.min(f[i][j], f[i-1][j+1] + val);
            }
        }
        int ans = MAX;
        for (int i = 0; i < n; i++) ans = Math.min(ans, f[n-1][i]);
        return ans;
    }
}

/**
 * @param {number[][]} matrix
 * @return {number}
 */
var minFallingPathSum = function(matrix) {
	let n = matrix.length;
  let f = new Array(n).fill(Number.MAX_SAFE_INTEGER).map(()=>new Array(n).fill(Number.MAX_SAFE_INTEGER));
  for(let i=0;i<n;i++){
    f[0][i] = matrix[0][i];
  }                   
  
  for(let i=1;i<n;i++){
    for(let j=0;j<n;j++){
      let val = matrix[i][j];
      f[i][j] = f[i-1][j] + val;
      if(j-1>=0){
        f[i][j] = Math.min(f[i][j],f[i-1][j-1]+val);
      }
      if(j+1<n){
        f[i][j] = Math.min(f[i][j],f[i-1][j+1]+val);
      }
    }
  }
  
  let ans = Number.MAX_SAFE_INTEGER
  for(let i=0;i<n;i++){
    ans = Math.min(ans,f[n-1][i])
  }
  return ans;
};

var minFallingPathSum = function(matrix) {
    let n = matrix.length;
    let dp = new Array(n).fill(Number.MAX_SAFE_INTEGER).map(()=>new Array(n).fill(Number.MAX_SAFE_INTEGER));
  

    for(let i=0; i<n; i++){
        for(let j=0; j<n; j++){
            // 边界
            if(i === 0){
                dp[i][j] = matrix[i][j];
            }else if(j === 0){
                // 最左边
                dp[i][j] = matrix[i][j] + Math.min(dp[i-1][j], dp[i-1][j+1]);
            }else if(j === n-1){
                // 最右边
                dp[i][j] = matrix[i][j] + Math.min(dp[i-1][j-1], dp[i-1][j]);
            }else{
                dp[i][j] = matrix[i][j] + Math.min(dp[i-1][j-1], dp[i-1][j], dp[i-1][j+1])
            }
        }
    }

    return dp[n-1].sort((a,b)=> a-b)[0];
};