［LeetCode］64. Minimum Path Sum

64. Minimum Path Sum

题意：计算从起始结点到终点结点的路径之和，使其相对最小。

假定dp[i][j]表示到达该位置的最小的和

分析：如果在第一行或者第一列，因为没有别的路可以选择，所以其和没有最小只说，只能进行累加；而其它的情况则可以通过上一个结点和左边一个结点的比较取其相对较小值，再加上自身即可。

所以状态转移方程为：

dp[i][j] = arr[i][j] + dp[i-1][j] (if j == 0 and i > 0)
dp[i][j] = arr[i][j] + dp[i][j-1] (if i == 0 and j > 0)
dp[i][j] = arr[i][j] + min(dp[i-1][j], dp[i][j-1])

动态规划

class Solution(object):
    def minPathSum(self, grid):
        """
        :type grid: List[List[int]]
        :rtype: int
        """
        dp = []
        row, col = len(grid), len(grid[0])
        for i in range(row):
            dp.append([0] * col)
        for i in range(row):
            for j in range(col):
                if i == 0:
                    dp[i][j] = dp[i][j-1] + grid[i][j] if j > 0 else grid[i][j]
                elif j == 0:
                    dp[i][j] = dp[i-1][j] + grid[i][j] if i > 0 else grid[i][j]
                else:
                    dp[i][j] = min(dp[i-1][j], dp[i][j-1]) + grid[i][j]
        return dp[row-1][col-1]

同样的，可以将二维数组浓缩成一维数组，代码如下：

class Solution(object):
    def minPathSum(self, grid):
        """
        :type grid: List[List[int]]
        :rtype: int
        """
        sum = list(grid[0])
        for j in range(1, len(grid[0])):
            sum[j] = sum[j - 1] + grid[0][j]
        for i in range(1, len(grid)):
            sum[0] += grid[i][0]
            for j in range(1,len(grid[0])):
                # 里面的sum[j]其实就是上一层计算出来的，即dp[i-1][j]，而sum[j-1]是当前层已经计算出来的，所以为dp[i][j-1]，最后取其最小更新为当前层的dp[i][j]
                sum[j] = min(sum[j - 1], sum[j]) + grid[i][j]
        return sum[-1]