leet64：最小路径和

最新推荐文章于 2021-03-02 06:16:33 发布

原创最新推荐文章于 2021-03-02 06:16:33 发布 · 145 阅读

0 ·

CC 4.0 BY-SA版权

leet动态规划专栏收录该内容

15 篇文章

订阅专栏

本文深入探讨了寻找矩阵中从左上角到右下角的最小路径和问题，提供了多种解决方案，包括动态规划、递归及空间优化方法，对算法理解和优化具有重要价值。

在这里插入图片描述

public static int minPathSum(int[][] grid) {
    int[][] dp = new int[grid.length][grid[0].length];
    for (int i = grid.length - 1; i >= 0; i--) {
        for (int j = grid[0].length - 1; j >= 0; j--) {
            if(i == grid.length - 1 && j != grid[0].length - 1)
                dp[i][j] = grid[i][j] +  dp[i][j + 1];
            else if(j == grid[0].length - 1 && i != grid.length - 1)
                dp[i][j] = grid[i][j] + dp[i + 1][j];
            else if(j != grid[0].length - 1 && i != grid.length - 1)
                dp[i][j] = grid[i][j] + Math.min(dp[i + 1][j], dp[i][j + 1]);
            else
                dp[i][j] = grid[i][j];
        }
    }
    return dp[0][0];
}

public int minPathSum(int[][] grid) {
    for (int i = grid.length - 1; i >= 0; i--) {
        for (int j = grid[0].length - 1; j >= 0; j--) {
            if(i == grid.length - 1 && j != grid[0].length - 1)
                grid[i][j] = grid[i][j] +  grid[i][j + 1];
            else if(j == grid[0].length - 1 && i != grid.length - 1)
                grid[i][j] = grid[i][j] + grid[i + 1][j];
            else if(j != grid[0].length - 1 && i != grid.length - 1)
                grid[i][j] = grid[i][j] + Math.min(grid[i + 1][j],grid[i][j + 1]);
        }
    }
    return grid[0][0];
}

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

    int row = grid.length;
    int col = grid[row - 1].length;

    int dp[][] = new int[row][col];

    dp[0][0] = grid[0][0];

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

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

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

    return dp[row - 1][col - 1];
}

递归

public int calculate(int[][] grid, int i, int j) {
    if (i == grid.length || j == grid[0].length) return Integer.MAX_VALUE;
    if (i == grid.length - 1 && j == grid[0].length - 1) return grid[i][j];
    return grid[i][j] + Math.min(calculate(grid, i + 1, j), calculate(grid, i, j + 1));
}
public int minPathSum(int[][] grid) {
    return calculate(grid, 0, 0);
}

空间压缩

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