最小路径和（DP / dfs+记忆化）

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

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

示例:

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

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/minimum-path-sum
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

这题的dfs+记忆化写法和三角形最小路径和（经典DP / dfs+记忆化）不同，不同之处在于递归出口的写法。在三角形那题中，因为行走方式是向下，所以if (i == triangle.size())的出口条件加Math.min(dfs(triangle, i + 1, j), dfs(triangle, i + 1, j + 1))不会发生少加一些数的情况。唉，算法不能完全照搬啊，需要总结加思考，这也是难处。DP倒是没有遇到什么问题，很容易想到。

//dfs+记忆化写法（自顶向下写法）
class Solution {

 	int memo[][];
	int dx[] = new int[]{1, 0};
	int dy[] = new int[]{0, 1};

    public int minPathSum(int[][] grid) {
    	memo = new int[grid.length][grid[0].length];
		for (int i=0; i<memo.length; i++) {
			Arrays.fill(memo[i], -1);
		}
    	return dfs(grid, 0, 0);
    }

    public int dfs(int[][] grid, int x, int y) {
    	if (memo[x][y] != -1) {
    		return memo[x][y];
    	}
    	if (x == grid.length-1 && y == grid[0].length-1) {
    		return grid[x][y];
    	}
    	int min = Integer.MAX_VALUE;
    	for (int i=0; i<2;i++) {
    		if (x+dx[i] < grid.length && y+dy[i] < grid[0].length) {
    			min = Math.min(dfs(grid, x+dx[i], y+dy[i]), min);
    		}    		
    	}
		memo[x][y] = min + grid[x][y];
    	return memo[x][y];
    }    
}

//DP
public class Main {

	public static void main(String[] args) {
		int grid[][] = new int[][]{{1,3,1},{1,5,1},{4,2,1}};
		System.out.println(minPathSum(grid));
	}
	
    public static int minPathSum(int[][] grid) {
    	int n = grid.length;
    	int m = grid[0].length;
    	int dp[][] = new int[n][m];
    	dp[0][0] = grid[0][0];
    	for (int i=1; i<n; i++) {
    		dp[i][0] = dp[i-1][0] + grid[i][0];
    	}
    	for (int i=1; i<m; i++){
    		dp[0][i] = dp[0][i-1] +  grid[0][i];
    	}
    	for (int i=1; i<n; i++) {
    		for (int j=1; j<m; j++) {
    			dp[i][j] = Math.min(dp[i-1][j], dp[i][j-1]) + grid[i][j];
    		}
    	}
    	return dp[n-1][m-1];
    }
}

 

来源：oschina

链接：https://my.oschina.net/u/4258423/blog/4428384