leetcode每日一题练习 使用golang和java实现 动态规划 最小路径和

题目要求

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

解题思路：动态规划

这道题明显就是动态规划，因为它满足将一个大问题分成许多小问题，而且每一个小问题的结果会对最终结果产生影响。这道题属于一个正向的dp问题。

首先处理(0,0)的数据，将其原封不动的放入dp数组，而且该位置相邻的两条边只有一个通路，因此直接与前一个数据相加，作为到达该点的最小路径。其他数据每个数据比较两个通路，哪一个更好一点，从而得到最优解。

用golang实现

func minPathSum(grid [][]int) int {
    if len(grid) == 0 || len(grid[0]) == 0 {
        return 0
    }
    m, n := len(grid), len(grid[0])
    dp := make([][]int, m)
    for i := 0; i < len(dp); i++ {
        dp[i] = make([]int, n)
    }
    dp[0][0] = grid[0][0]
    for i := 1; i < m; i++ {
        dp[i][0] = dp[i - 1][0] + grid[i][0]
    }
    for j := 1; j < n; j++ {
        dp[0][j] = dp[0][j - 1] + grid[0][j]
    }
    for i := 1; i < m; i++ {
        for j := 1; j < n; j++ {
            dp[i][j] = min(dp[i - 1][j], dp[i][j - 1]) + grid[i][j]
        }
    }
    return dp[m - 1][n - 1]
}

func min(a int,b int)int {
    if a>b{
        return b
    }else{
        return a
    }
}

时间复杂度：O（mn）我们使用了一个m x n的循环。
空间复杂度：O（mn）因为我们使用了一个dp[m][n]的数组。

使用java实现

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