[LeetCode 64] 最小路径和

题目描述

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

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

示例:

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

题目分析

这道题不就是把LeetCode 63的题目改编了一下嘛，最后的动态规划只需要把数组的值加起来取最小就行，看来选择路径这类问题，应该优先思考动态规划这种方法了。

源码

class Solution {
public int minPathSum(int[][] grid) {
    int row=grid.length,col=grid[0].length;
    int [][]dp=new int[row][col];
    //dp[i][j]表示到(i,j)的最小和
    for(int i=0;i<row;i++)
        for(int j=0;j<col;j++){
            if(i==0&&j==0)
            //从左上角开始
                dp[i][j]=grid[i][j];
            else if(i==0)
            //第一行
                dp[i][j]=dp[i][j-1]+grid[i][j];
            else if(j==0)
            //第一列
                dp[i][j]=dp[i-1][j]+grid[i][j];
            else
            //中间的取最小值加
                dp[i][j]=Math.min(dp[i-1][j],dp[i][j-1])+grid[i][j];
        }
    return dp[row-1][col-1];
}
}

改进

当然，在没有时间限制的前提下，还有一种方法，那就是递归。或者说的更明白一点就是DFS。但是要注意前提，是没有时间限制，DFS的时间复杂度太高了，并不能通过最后的测试，不过也是可行的啦。

改进代码

class Solution {
public int minPathSum(int[][] grid) {
    return digui(grid,grid.length-1,grid[0].length-1);
}
public int digui(int[][] arr,int row,int col){
    if(row == 0 && col == 0){
        return arr[row][col];
    }
    if(row != 0 && col == 0){
        return arr[row][col]+digui(arr,row-1,col);
    }
    if(row == 0 && col != 0){
        return arr[row][col]+digui(arr,row,col-1);
    }
    return arr[row][col]+Math.min(digui(arr,row-1,col),digui(arr,row,col-1));
}
}

分析

第一个时间复杂度为O（n^2）
第二个时间复杂度为O（n*m）空间复杂度明显高，用到了额外的空间。

难点

这道题就是很基础的动态规划，遍历一遍二维数组，然后不是一整列，不是一整行，就是取右下路径的最小值啦。

小结

这道题就很考验对时间复杂度的把控了，递归是肯定超时的，那么对于路径选择，还是好好用动态规划吧。

[1]https://leetcode-cn.com/problems/minimum-path-sum/comments/