64. Minimum Path Sum [Medium]

原创于 2021-03-24 19:22:28 发布 · 200 阅读

0 ·

本内容遵循CC 4.0 BY-SA版权协议

标签

#leetcode

刷题专栏收录该内容

175 篇文章

订阅专栏

这篇博客探讨了几种不同的方法来计算二维网格中从左上角到右下角的最小路径和，包括基础的二维动态规划、优化后的动态规划实现、空间复杂度优化以及递归解法。每种方法都注重了效率和空间使用，并通过代码示例进行了详细解释。

第二次：

有进步

/**
 * 基础二维动态规划，也可以recursion + mem
 * Runtime: 2 ms, faster than 79.44%
 * Memory Usage: 42 MB, less than 12.20%
 */
class Solution {
    public int minPathSum(int[][] grid) {
        int m = grid.length, n = grid[0].length;
        int[][] dp = new int[m][n];
        dp[0][0] = grid[0][0];
        for (int i = 1; i < n; i++) {
            dp[0][i] = dp[0][i - 1] + grid[0][i];
        }
        for (int i = 1; i < m; i++) {
            dp[i][0] = dp[i - 1][0] + grid[i][0];
            for (int j = 1; j < n; j++) {
                dp[i][j] = grid[i][j] + Math.min(dp[i - 1][j], dp[i][j - 1]);
            }
        }
        return dp[m - 1][n - 1];
    }
}

第一次：

/**
 * 自己的代码
 * 好久没接触动态规划了，思路没错，但数组下标写的比较绕，也没必要用两个循环去初始化dp数组
 */
class Solution {
    public int minPathSum(int[][] grid) {
        if (grid == null || grid.length == 0 || grid[0].length == 0) return 0;
        int[][] dp = new int[grid.length + 1][grid[0].length + 1];
        for (int i = 1; i <= grid[0].length; i++)
            dp[1][i] = dp[1][i - 1] + grid[0][i - 1];
        for (int i = 2; i <= grid.length; i++)
            dp[i][1] = dp[i - 1][1] + grid[i - 1][0];
        for (int i = 2; i <= grid.length; i++)
            for (int j = 2; j <= grid[0].length; j++)
                dp[i][j] = Math.min(dp[i - 1][j], dp[i][j - 1]) + grid[i - 1][j - 1];
        return dp[grid.length][grid[0].length];
    }
}

/**
 * 和上面一模一样的想法，代码组织的更好一点
 */
class Solution {
    public int minPathSum(int[][] grid) {
        if (grid == null || grid.length == 0 || grid[0].length == 0) return 0;
        int[][] dp = new int[grid.length][grid[0].length];
        dp[0][0] = grid[0][0];
        for (int i = 1; i < grid[0].length; i++) // 初始化dp第一行
            dp[0][i] = dp[0][i - 1] + grid[0][i];
        for (int i = 1; i < grid.length; i++) {
            dp[i][0] = dp[i - 1][0] + grid[i][0]; // 初始化dp第一列，在求dp矩阵的外围循环下做，没必要再单独一个循环
            for (int j = 1; j < grid[0].length; j++)
                dp[i][j] = Math.min(dp[i - 1][j], dp[i][j - 1]) + grid[i][j];
        }
        return dp[grid.length - 1][grid[0].length - 1];
    }
}

/** 
 * 仍然是动态规划思想，但不新建dp数组，直接修改grid中的数据，空间复杂度O(1)
 * （但有的题是不允许修改原数组的）
 */
class Solution {
    public int minPathSum(int[][] grid) {
        if (grid == null || grid.length == 0 || grid[0].length == 0) return 0;
        for (int i = 1; i < grid[0].length; i++)
            grid[0][i] = grid[0][i - 1] + grid[0][i];
        for (int i = 1; i < grid.length; i++) {
            grid[i][0] = grid[i - 1][0] + grid[i][0];
            for (int j = 1; j < grid[0].length; j++)
                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];
    }
}

/**
 * 递归写法，会Time Limit Exceeded
 * 递归和动态规划本质的想法是一样的，但是动态规划的方法存储了计算过的值，用空间换时间
 */
class Solution {
    public int minPathSum(int[][] grid) {
        return minPathSum(grid, grid.length - 1, grid[0].length - 1);
    }
    private int minPathSum(int[][] grid, int row, int col) {
        if (row == 0 && col == 0) return grid[0][0];
        if (row == 0) return minPathSum(grid, row, col - 1) + grid[row][col];
        if (col == 0) return minPathSum(grid, row - 1, col) + grid[row][col];
        return Math.min(minPathSum(grid, row, col - 1), minPathSum(grid, row - 1, col)) + grid[row][col];
    }
}