leetcode64. 最小路径和

题目

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

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

示例:

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

解题

• 记忆化 搜索

class Solution {
    int[][] memo;
    public int minPathSum(int[][] grid) {
        if (grid == null || grid.length < 1) {
            return 0;
        }
        int m = grid.length;
        int n = grid[0].length;
        initMemo(m, n);
        return minPathSum(grid, 0, 0);
    }

    private int minPathSum(int[][] grid, int x, int y) {
        if (x >= grid.length || y >= grid[0].length) {
            return 0;
        }
        if (memo[x][y] != 0) {
            return memo[x][y];
        }

        // {x,y}点的最小路径 = grid[x][y] + 左右侧节点路径的最小值
        // 右侧节点路径最小值
        int right = 0;
        if (x == grid.length - 1 && y == grid[0].length - 1) {
            memo[x][y] = grid[x][y];
        } else if (x == grid.length - 1) {
            memo[x][y] = grid[x][y] + minPathSum(grid, x, y + 1);
        } else if (y == grid[0].length - 1) {
            memo[x][y] = grid[x][y] + minPathSum(grid, x + 1, y);
        } else {
            memo[x][y] = grid[x][y] + Math.min(minPathSum(grid, x + 1, y), minPathSum(grid, x, y + 1));
        }

        return memo[x][y];
    }

    private void initMemo(int m, int n) {
        memo = new int[m][n];
        for (int i = 0; i < memo.length; i++) {
            memo[i] = new int[n];
        }
    }

}

• 动态规划

class Solution {
    int[][] result;
    public int minPathSum(int[][] grid) {
        if (grid == null || grid.length < 1) {
            return 0;
        }
        int m = grid.length;
        int n = grid[0].length;
        initResult(m, n);
        for (int i = m - 1; i >= 0; i--) {
            for (int j = n - 1; j >= 0; j--) {
                result[i][j] = grid[i][j] + min(result, i, j + 1, i + 1, j);
            }
        }
        return result[0][0];
    }

    // 获取result中坐标{x1,y1},{x2,y2}中较小的一个
    // 存在一个点坐标越界时, 返回另外一个点的值
    // 存在两个点坐标越界时, 返回0
    private int min(int[][] result, int x1, int y1, int x2, int y2){
        int m = result.length;
        int n = result[0].length;
        // 点1越界
        if (x1 >= m || y1 >=n){
            // 点1点2同时越界
            if (x2 >= m || y2 >=n){
                return 0;
            } else {
                return result[x2][y2];
            }
        } else {
            if (x2 >= m || y2 >=n){
                return result[x1][y1];
            } else {
                return Math.min(result[x1][y1], result[x2][y2]);
            }
        }
    }

    private void initResult(int m, int n) {
        result = new int[m][n];
        for (int i = 0; i < result.length; i++) {
            result[i] = new int[n];
        }
    }
}