Leetcode 64. 最小路径和 Java

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

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

示例:

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

这道题的总体解决思路，还是和70号问题爬楼梯一样，题目相比于70号问题，稍难一些，但是思路还是一样的。

首先我们自上而下的思考问题，定义出递归函数，我们只需要一个函数，给出起始位置的坐标，返回从这个坐标到终点的最小路径就好，然后我们从起点开始，向右走一步，向下走一步，看看哪个路径最小，即为最后答案。同样在递归的过程中，我们把递归的中间过程保存下来，提高程序效率。

public int minPathSum(int[][] grid) {
        if (grid.length == 0) {
            return 0;
        }

        int m = grid.length;
        int n = grid[0].length;

        memo = new int[m][n];

        return getMin(grid, m, n, 0, 0);
    }

    private int[][] memo;

    
    //记忆化搜索
    private int getMin(int[][] grid, int m, int n, int startX, int startY) {
        if (startX == m - 1 && startY == n - 1) {
            return grid[startX][startY];
        }

        if (startX > m - 1 || startY > n - 1) {
            return Integer.MAX_VALUE;
        }

        if (memo[startX][startY] != 0) {
            return memo[startX][startY];
        }

        memo[startX][startY] = grid[startX][startY] + Math.min(getMin(grid, m, n, startX + 1, startY), getMin(grid, m, n, startX, startY + 1));
        return memo[startX][startY];
    }

在记忆化搜索的过程中，我们总结出了状态转移方程，便可以从下往上的进行递推。

public int minPathSum(int[][] grid) {
        if (grid.length == 0) {
            return 0;
        }

        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 < M; i++) {
            dp[0][i] = grid[0][i] + dp[0][i - 1];
        }

        for (int i = 1; i < N; i++) {
            dp[i][0] = grid[i][0] + dp[i - 1][0];
        }

        for (int i = 1; i < grid.length; i++) {
            for (int j = 1; j < grid[i].length; j++) {
                dp[i][j] = Math.min(dp[i - 1][j], dp[i][j - 1]) + grid[i][j];
            }
        }

        return dp[N - 1][M - 1];
    }

通过这道题目，对比70号题目，同学们可以仔细替换一下记忆化搜索和动态规划这两种思路间的联系与不同。