LeetCode-64.最小路径和

LeetCode-64.最小路径和

一、题目内容

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

说明：每次只能向下或者向右移动一步。
示例:
输入:
[
[1,3,1],
[1,5,1],
[4,2,1]
]
输出: 7
解释: 因为路径 1→3→1→1→1 的总和最小。

二、题解过程

1、问题分析

求最值问题最先想到的就是动态规划问题。动态规划的核心问题就是穷举。因为要求最值，肯定要把所有可行的答案穷举出来，然后求最值。但是动态规划有点特别，因为这类问题存在[重叠子问题]，如果暴力穷举的话，效率会及其底下，所以需要[备忘录]或者[DP table]来优化穷举过程，避免不必要的计算。

2、转态定义

dp[i][j]表示走到位置(i,j)的最小路径总和，这里的位置i，j指的是三角形中的第 i 行，第j列。

3、状态转移

我们可以把dp[i][j]代表到达第i行，第j列的最小路径，则状态转移方程表示如下：
dp[i][j] = min(dp[i-1][j],dp[i][j-1]) + grid[i][j]
对于如下情况需要单独考虑：
1）当取dp[i][0]时，此时不存在dp[i][j-1]的来源，因此，当j=0时，状态转移方程如下：
dp[i][j] = dp[i-1][j] + grid[i][j]
2) 当取dp[0][j]时，此时不存在dp[i-1][j]的来源，因此，当i=0时，状态转移方程如下：
dp[i][j] = dp[i][j-1] + grid[i][j]

4、解法一代码：

时间/空间复杂度是 O(mn)/O(mn).

// A code block
Class Solution{
	public int minPathSum(int[][] grid) {
		int m = grid.length;
		int n = grid[0].length;
		int [][] dp = new int[m][n];
        int ruleCount;
        dp[0][0] = grid[0][0];

        for (int i = 0; i < m; i++){
            for (int j = 0; j < n; j++){
            	if (i == 0 && j != 0) {
            		dp[i][j] = dp[i][j-1] + grid[i][j];
            	}
                if(i != 0 && j == 0) {
                    dp[i][j] = dp[i-1][j] + grid[i][j];
                }
                if(i != 0 && j != 0) {
                    dp[i][j] = Math.min(dp[i-1][j],dp[i][j-1]) + grid[i][j];
                }
            }
        }
        return dp[m-1][n-1];  
    }
}

5.解法二-空间复杂度优化

时间/空间复杂度是 O(mn)/O(1).

class Solution {
    public int minPathSum(int[][] grid) {
        for(int i = 0; i < grid.length; i++) {
            for(int j = 0; j < grid[0].length; j++) {
                if(i == 0 && j == 0) continue;
                else if(i == 0)  grid[i][j] = grid[i][j - 1] + grid[i][j];
                else if(j == 0)  grid[i][j] = grid[i - 1][j] + grid[i][j];
                else grid[i][j] = Math.min(grid[i - 1][j], grid[i][j - 1]) + grid[i][j];
            }
        }
        return grid[grid.length - 1][grid[0].length - 1];
    }
}