LeetCode 64 最小路径和（中等）

最新推荐文章于 2024-08-12 21:16:30 发布

嗷嗷嗷嗷_

最新推荐文章于 2024-08-12 21:16:30 发布

阅读量77

点赞数

分类专栏：算法 # LeetCode 热题 HOT 100 文章标签：动态规划递归回溯 leetcode

本文链接：https://blog.csdn.net/qq_36714200/article/details/109236583

版权

算法同时被 3 个专栏收录

94 篇文章 0 订阅

订阅专栏

LeetCode 热题 HOT 100

78 篇文章 0 订阅

订阅专栏

LeetCode

50 篇文章 0 订阅

订阅专栏

本文探讨了如何使用动态规划和回溯递归算法求解从网格左上角到右下角的最小路径和问题。两种方法对比，包括常规动态规划的O(mn)时间和O(mn)空间复杂度，以及优化后的动态规划以O(n)空间节省，以及递归方法的潜在性能瓶颈。

摘要由CSDN通过智能技术生成

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

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

示例:

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

动态规划
时间复杂度 O(mn)
空间复杂度 O(mn)

class Solution {
    public int minPathSum(int[][] grid) {
        int row = grid.length;
        int col = grid[0].length;
        int[][] dp = new int[row][col];

        for (int i = 0; i < row; i++){
            for (int j = 0; j < col; 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[row-1][col-1];
    }
}

动态规划优化

时间复杂度 O(mn)
空间复杂度 O(n)

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

回溯递归

如果矩阵较大，可能导致递归深度太深，超出时间限制。

class Solution {
    int minPath = Integer.MAX_VALUE;
    int sum = 0;
    public int minPathSum(int[][] grid) {
        backtrack(grid, 0, 0);
        return minPath;
    }

    public void backtrack(int[][] grid, int i, int j){
        if (i == grid.length - 1 && j == grid[0].length - 1){
            minPath = Math.min(minPath, sum + grid[i][j]);
            return;
        }

        sum += grid[i][j];

        if (i < grid.length - 1){
            backtrack(grid, i+1, j);
        }
        if (j < grid[0].length - 1)
            backtrack(grid, i, j+1);

        sum -= grid[i][j];
    }
}