LeetCode64. 最小路径和——动态规划

LeetCode64. 最小路径和

描述

给定一个包含非负整数的 m x n 网格 grid ，请找出一条从左上角到右下角的路径，使得路径上的数字总和为最小。

说明：每次只能向下或者向右移动一步。

示例 1：

输入：grid = [[1,3,1],[1,5,1],[4,2,1]]
输出：7
解释：因为路径 1→3→1→1→1 的总和最小。

示例 2：

输入：grid = [[1,2,3],[4,5,6]]
输出：12

提示：

m == grid.length
n == grid[i].length
1 <= m, n <= 200
0 <= grid[i][j] <= 200

题解

• 数组含义
  dp[i][j] 即为 从左上角走到右下角的路径和
• 关系式
  向左走：dp[i-1][j]
  向上走：dp[i][j-1]
  当前网格中的路径值： arr[i][j]
  dp[i][j] = Math.min(dp[i-1][j],dp[i][j-1])+arr[i][j]
• 初始值
  最上面一行：只能向左走
  dp[0][j] = arr[0][j]+dp[0][j-1];
  最左面一列：只能向上走
  dp[i][0] = arr[i][0]+dp[i-1][0];

class Solution {
    public int minPathSum(int[][] grid) {
// - 数组含义
//   dp[i][j] 即为 从左上角走到右下角的路径和
// - 关系式
//   向左走：dp[i-1][j]
//   向上走：dp[i][j-1]
//   当前网格中的路径值： arr[i][j]
//   dp[i][j] = Math.min(dp[i-1][j],dp[i][j-1])+arr[i][j]
// - 初始值
//   最上面一行：只能向左走
//   dp[0][j] = arr[0][j]+dp[0][j-1];
//   最左面一列：只能向上走
//   dp[i][0] = arr[i][0]+dp[i-1][0];
        int m = grid.length;
        int n = grid[0].length;
        // 0
        if(m<=0||n<=0){
            return 0;
        }
        // dp初始化
        int [][] dp = new int [m][n];
        // 初始值
        dp[0][0]=grid[0][0];
        for(int i = 1;i<m;i++){
            dp[i][0]=grid[i][0]+dp[i-1][0];
        }
        for(int j =1;j<n;j++){
            dp[0][j]=dp[0][j-1]+grid[0][j];
        }
        // 计算dp[i][j]
        for(int i=1;i<m;i++){
            for(int j=1;j<n;j++){
                dp[i][j]=Math.min(dp[i-1][j],dp[i][j-1])+grid[i][j];
            }
        }
        return dp[m-1][n-1];
    }
}