力扣64.最小路径和

转载

Lucky小黄人 2021-05-30 09:57:19

64. 最小路径和

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

输入:

[
  [1,3,1],
  [1,5,1],
  [4,2,1]
]
输出: 7
解释: 因为路径 1→3→1→1→1 的总和最小

思路一：动态规划

这是一道典型的动态规划题
dp[i][j]表示从起点到达(i, j)位置的最小路径和，

状态转移方程

dp[i][j] = Math.min(dp[i - 1][j],dp[i][j-1]) + m[i][j];

边界值
dp[i][0] = dp[i-1][0] + m[i][0]
dp[0][j] = dp[0][j-1] + m[0][j]

class Solution {
    public int minPathSum(int[][] grid) {

        if(grid == null || grid.length == 0){
            return Integer.MAX_VALUE;
        }
        int rlen = grid.length;
        int clen = grid[0].length;
        int[][] dp = new int[rlen][clen];
        // 初始化边界值
        dp[0][0] = grid[0][0];
        for(int i = 1; i < rlen; i++){
            dp[i][0] = dp[i-1][0] + grid[i][0];
        }
        for(int j = 1; j < clen; j++){
            dp[0][j] = dp[0][j-1] + grid[0][j];
           
        }

        for(int i = 1; i < rlen; i++){
            for(int j = 1; j < clen; j++){
                dp[i][j] = Math.min(dp[i-1][j], dp[i][j-1]) + grid[i][j];
            }
        }
        return dp[rlen - 1][clen - 1];
    }
}

力扣测试时间为3ms, 空间为42.3MB

复杂度分析：

时间复杂度为O(n*m)

空间复杂度也是O(mn)

注意，

因为这题求的最小值，所以不能用开辟 (ows+1)*(cols+1)个空间来代替边界初始化, 因为在在边界处 Math.min(dp[i-1][j], dp[i][j-1]) 肯定等于0，那d[i][0]或者dp[0][j]肯定等于grid[i][j]，这是明显错误的。

 1 class Solution {
 2     public int minPathSum(int[][] grid) {
 3         // 动态规划，dp[i][j]表示从起点到达(i,j)经过的路径最小和
 4         if(grid == null || grid.length == 0 || grid[0].length == 0){
 5             return 0;
 6         }
 7         int rows = grid.length;
 8         int cols = grid[0].length;
 9         int[][] dp = new int[rows+1][cols+1];
10         for(int i = 1; i <= rows; i++){
11             for(int j = 1; j <= cols; j++){
12                 dp[i][j] = Math.min(dp[i-1][j], dp[i][j-1]) + grid[i-1][j-1];
13             }
14         }
15         return dp[rows][cols];
16     }
17 }

但是这题求的是最大值，那么是可以这样做来简化代码的。

思路二：利用一维数组进行动态规划

dp数组大小等于矩阵的列的数目

状态转移方程

dp[j] = dp[0] + grid[i][j]; (j == 0)
dp[j] = Math.min(dp[j], dp[j-1]) + grid[i][j]; (j != 0)，因为dp[j-1]在dp[j]之前就已经计算出来，已经包含了grid[i][j-1], 所以是没有问题的。dp[j]（等式左边的dp[j]）就相当于是上面的dp[i-1][j], dp[j-1]就相当于上面的dp[i][j-1],

所以dp[j] = Math.min(dp[j], dp[j-1]) + grid[i][j];这时候没问题的。

边界值
dp[j] = dp[j-1] + grid[0][j]; // 初值

 1 class Solution {
 2     public int minPathSum(int[][] grid) {
 3         if(grid == null || grid.length == 0){
 4             return Integer.MAX_VALUE;
 5         }
 6         int rlen = grid.length;
 7         int clen = grid[0].length;
 8         int[] dp = new int[clen];
 9         // 初始化边界值
10         dp[0] = grid[0][0];
11         
12         for(int j = 1; j < clen; j++){
13             dp[j] = dp[j-1] + grid[0][j];
14         }
15 
16         for(int i = 1; i < rlen; i++){
17             for(int j = 0; j < clen; j++){
18                 if(j == 0){
19                     dp[j] = dp[0] + grid[i][j];     // 每行第0列元素
20                 }else{
21                     dp[j] = Math.min(dp[j-1], dp[j]) + grid[i][j];
22                 }
23             }
24         }
25         return dp[clen - 1];
26     }
27 }

力扣测试时间2ms, 空间为41.9MB

复杂度分析：

时间复杂度为O(nm)

空间复杂度为O(n), n为列的数目

思路三：无额外空间的动态规划

由于每个grid[i][j]只使用一次，所以完全可以用grid[i][j]来作为dp数组

 1 class Solution {
 2     public int minPathSum(int[][] grid) {
 3         if(grid == null || grid.length == 0){
 4             return Integer.MAX_VALUE;
 5         }
 6         int rlen = grid.length;
 7         int clen = grid[0].length;
 8         
 9         // 初始化边界值
10         for(int i = 1; i < rlen; i++){
11             grid[i][0] = grid[i-1][0] + grid[i][0];
12         }
13         for(int j = 1; j < clen; j++){
14             grid[0][j] = grid[0][j-1] + grid[0][j];
15            
16         }
17 
18         for(int i = 1; i < rlen; i++){
19             for(int j = 1; j < clen; j++){
20                 grid[i][j] = Math.min(grid[i-1][j], grid[i][j-1]) + grid[i][j];
21             }
22         }
23         return grid[rlen - 1][clen - 1];
24     }
25 }