64. Minimum Path Sum

最新推荐文章于 2024-04-14 17:31:16 发布

原创最新推荐文章于 2024-04-14 17:31:16 发布 · 99 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#Minimum Path Sum

LeetCode 专栏收录该内容

5 篇文章

订阅专栏

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,这里没必要用闭包，纯粹转笔）

class Solution:
    def minPathSum(self, grid: List[List[int]]) -> int:
        return self.outer(grid)
           
    def outer(self,grid):
        col=len(grid[0])
        row=len(grid)
        
        def inner(m,n):      
            if n==col-1 and m==row-1:
                return grid[m][n]
            elif m==row-1 and n<col-1:
                return inner(m,n+1)+grid[m][n]
            elif n==col-1 and m<row-1:
                return inner(m+1,n)+grid[m][n]
            else:
                return min(inner(m+1,n),inner(m,n+1))+grid[m][n]
        return inner(0,0)

稍微改一改就是动态规划了（不知道算不算）这次勉强通过leetCode

class Solution:
    def minPathSum(self, grid: List[List[int]]) -> int:
        return self.outer(grid)
           
    def outer(self,grid):
        col=len(grid[0])
        row=len(grid)
        MPS = [[0]*col for i in range(row)]
        def inner(m,n):
            if MPS[m][n]!=0:
                return MPS[m][n]
            if n==col-1 and m==row-1:
               # print(m,n,row,col)
                MPS[m][n] = grid[m][n]
                return MPS[m][n]
            elif m==row-1 and n<col-1:
                MPS[m][n]=inner(m,n+1)+grid[m][n]
                return  MPS[m][n]
            elif n==col-1 and m<row-1:
                MPS[m][n] = inner(m+1,n)+grid[m][n]
                return MPS[m][n]
            else:
                MPS[m][n] = min(inner(m+1,n),inner(m,n+1))+grid[m][n]
                return  MPS[m][n]
        return inner(0,0)

更好的动态规划，别人的代码

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