[LeetCode] 64. Minimum Path Sum_Medium tag: Dynamic Programming

Given a m x n grid filled with non-negative numbers, find a path from top left to bottom right which minimizes the sum of all numbers along its path.

Note: You can only move either down or right at any point in time.

Example:

Input:
[
  [1,3,1],
  [1,5,1],
  [4,2,1]
]
Output: 7
Explanation: Because the path 1→3→1→1→1 minimizes the sum.

其实这个题目的思路是跟[LeetCode] 62. Unique Paths_ Medium tag: Dynamic Programming很像, 只不过一个是步数, 一个是minimal sum而已. 还是可以用滚动数组的方法, 只是需要注意
初始化即可.

1. Constraints
1) [0*0] 最小

2. Ideas

Dynamic Programming     T: O(m*n)   S: O(n)  optimal(using rolling array)

3. Code

 class Solution(object):
     def minPathSum(self, grid):
         # S; O(m*n)
         if not grid or len(grid[0]) == 0: return 0
         m, n = len(grid), len(grid[0])
         if m == 1 or n == 1: return sum(sum(each) for each in grid)
         ans = grid
         for i in range(m):
             for j in range(n):
                 if i == 0 and j!= 0:
                     ans[i][j] = ans[i][j-1] + grid[i][j]
                 if j == 0 and i!= 0:
                     ans[i][j] = ans[i-1][j] + grid[i][j]
                 if j >0 and i >0 :
                     ans[i][j] = min(ans[i-1][j], ans[i][j-1]) + grid[i][j]
         return ans[-1][-1]

2)

class Solution:
    def minPathSum(self, grid):
        m, n = len(grid), len(grid[0])
        mem = [[0]* n for _ in range(m)]
        mem[0][0] = grid[0][0]
        for i in range(1, m):
            mem[i][0] = grid[i][0] + mem[i - 1][0]
        for i in range(1, n):
            mem[0][j] = grid[0][j] + mem[0][j - 1]
        for i in range(1, m):
            for j in range(1, n):
                mem[i][j] = grid[i][j] + min(mem[i - 1][j], mem[i][j - 1])
        return mem[m - 1][n - 1]

4. Test cases

[
  [1,3,1],
  [1,5,1],
  [4,2,1]
]
Output: 7