算法（动态规划）----最短路径和

最短路径和

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

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

示例:

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

解法1：递归 

对于每个元素我们考虑两条路径，向右走和向下走，在这两条路径中挑选路径权值和较小的一个。

递归公式：cost(i,j)=grid[i][j]+min(cost(i+1,j),cost(i,j+1))

意思就是从当前位置到右下角的最短路径就等于当前位置的值加上向右走的最短路径和向下走的最短路径中较小的哪一个。

 

解法2：动态规划

上面的递归其实会有很多重复计算，例如从（0,0）位置开始移动，（1,1）位置会被重复计算两次。为了消除重复计算。我们可以使用一个和grid数组大小相同的数组dp来记录每个位置上最短路径。

                                    

第一种方法：模拟递归过程

设dp[i][j]代表从（i，j）位置到右下角的最短路径。我们最终求的就是（0,0）位置到右下角的最短路径和，即dp[0][0]

• 根据dp的定义，我们可以找到base case即哪些位置的值不依赖于其他的值。很明显，在dp的定义下，只有右下角位置的值不依赖于其他的值，所以，我们可以对其进行初始化。
• 然后我们分析普遍的依赖关系，即状态转移方程。因为只能通过向右或向下移动，所以（i，j）位置到右下角的最短路径为：

                             dp(i,j)=grid(i,j)+min(dp(i+1,j),dp(i,j+1))

•    意思也就是（i，j）位置到右下角的最短路径就等于当前位置的值加上右面一格位置到右下角的最小值和下面一格位置到右下角的最小值中较小的那一个值。
• 时间复杂度为O(m*n)

//递归存在很多重复计算，使用动态规划，记录路径，减少重复计算，dp[i][j]代表从当前位置到右下角的最短路径
	public static int minPathSum(int[][] grid) {
		int x=grid.length;
		int y=grid[0].length;
		int[][] dp=new int[x][y];	
		for(int i=x-1;i>=0;i--){
			for(int j=y-1;j>=0;j--){
				if(i==grid.length-1&&j==grid[i].length-1){
					dp[i][j]=grid[i][j];
				}else if (i==grid.length-1) {
					dp[i][j]=grid[i][j]+dp[i][j+1];
				}else if (j==grid[i].length-1) {
					dp[i][j]=grid[i][j]+dp[i+1][j];
				}else {
					dp[i][j]=grid[i][j]+Math.min(dp[i+1][j], dp[i][j+1]);
				}
			}
		}
		return dp[0][0];
        
    }

第二种方法：正常动规思路

dp[i][j]代表从左上角（0,0）位置走到到（i，j）位置的最短路径。我们最终求的就是从（0,0）位置到右下角的最短路径和，即dp[grid.length-1][grid[0].length-1]

• 根据dp的定义，我们可以找到base case即哪些位置的值不依赖于其他的值。很明显，在dp的定义下，只有左上角（0,0）位置的值不依赖于其他的值，所以，我们可以对其进行初始化。
• 然后我们分析普遍的依赖关系，即状态转移方程。因为只能通过向右或向下移动，所以（i，j）位置到右下角的最短路径为：

                                    dp(i,j)=grid(i,j)+min(dp(i-1,j),dp(i,j-1))

• 意思就是从（0,0）位置到（i，j）位置的最短路径，就等于当前位置的值加上从（0，0）位置到左边一格位置（i,j-1）的最短路径和从（0，0）位置到上边一格位置（i-1,j）的最短路径中较小的那一个值。
• 时间复杂度为O(m*n)

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