leetcode-64：Minimum Path Sum

声明：

1、本文仅为学习笔记，不得商用

2、文中所引文献，已在参考资料中说明，但部分来源于网络，出处无可考究，如果文中引用了您的原创，请您私信我

3、如果内容有错误或者不准确的地方请大家指正

题目网址

题目大意

解题思路
枚举法

动态规划
代码实现

代码优化

题目网址

https://leetcode.com/problems/minimum-path-sum/

题目大意

一个m行n列的二维数组，每个元素是一个非负数，从左上角走到右下角，每次只能朝右或者朝下走，不能走出矩阵，使得总和最小。

解题思路

枚举法

一共走m+n-2步，向下走n-1步，向又走m-1步，枚举是万能的但是不可行。

动态规划

这是一道典型的动态规划的问题。

设置一个数组dp，其中dp[i][j]表示的是从左上到达(i,j)的最小值

最主要的就是找到递推式

dp[i][j]=min(dp[i-1][j],dp[i][j-1])+a[i][j]

dp矩阵最右下角的值，就是整个问题的答案

分两种情况：

从上面过来dp[i-1][j]+a[i][j]

从右面过来dp[i][j-1]+a[i][j]

有了递推式之外，还需要有初值

dp[0][0]=a[0][0]

dp[0][j>0]=dp[0][j-1]+a[0][j]

dp[i>0][0]=dp[i-1][0]+a[i][0]

复杂度

时间复杂度O(m∗n)空间复杂度O(m∗n)

代码实现

public class Solution {
public int minPathSum(int[][] grid) {
if(grid == null || grid.length == 0 || grid[0].length == 0){
return 0;
}
//m代表行数
int m = grid.length;
//n代表列数
int n = grid[0].length;
//路径的矩阵
int[][] dp = new int[m]
;
dp[0][0] = grid[0][0];
//第一行，只能从左往右走
for(int i = 1; i < n; i++){
dp[0][i] = dp[0][i-1] + grid[0][i];
}
//第一列，只能从上往下走
for(int j = 1; j < m; j++){
dp[j][0] = dp[j-1][0] + grid[j][0];
}
for(int i = 1; i < m; i++){
for(int j = 1; j < n; j++){
int temp = dp[i-1][j] > dp[i][j-1] ? dp[i][j-1] : dp[i-1][j];
dp[i][j] = temp + grid[i][j];
}
}
return dp[m-1][n-1];
}
}

代码优化

可以继续优化空间复杂度优化为O(min(m,n))

即不使用(m∗n)的数组而改用min(m,n)的数组

这里直接使用n，按理应该取m，n的最小值，但要交换m和n

省略掉一维，dp[i][j]只与dp[i-1][j]和dp[i][j-1]有关

对于每个i，正向循环j，之前的dp[j-1]是新的，而d[j]还是旧的

dp[j]=min(dp[j-1],dp[j])+a[i][j]

public class Solution {
public int minPathSum(int[][] grid) {
if(grid == null || grid.length == 0 || grid[0].length == 0){
return 0;
}
// write your code here
//m代表行数
int m = grid.length;
//n代表列数
int n = grid[0].length;
//路径的矩阵
int[] dp = new int
;
for(int i = 0; i < m; i++){
for(int j = 0; j < n; j++){
if(i == 0){
if(j == 0){
dp[j] = grid[i][j];
}else{
dp[j] = dp[j-1] + grid[i][j];
}
}else if(j==0){
dp[j] = dp[j] + grid[i][j];
}else{
//min(dp[i][j-1],dp[i-1][j])
int temp = dp[j-1] > dp[j] ? dp[j] : dp[j-1];
dp[j] = temp + grid[i][j];
}
}
}
return dp[n-1];
}
}