本文共 2858 字，大约阅读时间需要 9 分钟。

矩阵路径

问题描述

一个机器人位于一个 m x n 网格的左上角，起始点标记为“Start”。机器人每次只能向下或者向右移动一步，目标是到达网格的右下角“Finish”。问总共有多少条不同的路径？

示例：输入：m = 3, n = 7，输出：28。

思路分析

解决代码

class Solution:
    def uniquePaths(self, m: int, n: int) -> int:
        if m == 0 or n == 0:
            return 0
        dp = [[0] * n for _ in range(m)]
        for i in range(m):
            dp[i][0] = 1
        for j in range(n):
            dp[0][j] = 1
        for i in range(1, m):
            for j in range(1, n):
                dp[i][j] = dp[i-1][j] + dp[i][j-1]
        return dp[-1][-1]

时间复杂度

• 时间复杂度：O(mn)
• 空间复杂度：O(mn)

不同路径II

问题描述

一个机器人位于一个 m x n 网格的左上角，起始点标记为“Start”。网格中有障碍物，障碍物和空位置分别用 1 和 0 表示。问从左上角到右下角的不同路径数？

示例：障碍物Grid = [[0,0,0],[0,1,0],[0,0,0]]，输出：2。

思路分析

解决代码

class Solution:
    def uniquePathsWithObstacles(self, obstacleGrid: List[List[int]]) -> int:
        if not obstacleGrid or not obstacleGrid[0]:
            return 0
        m = len(obstacleGrid)
        n = len(obstacleGrid[0])
        dp = [[0] * n for _ in range(m)]
        for i in range(m):
            dp[i][0] = 1 if obstacleGrid[i][0] == 0 else 0
        for j in range(n):
            dp[0][j] = 1 if obstacleGrid[0][j] == 0 else 0
        for i in range(1, m):
            for j in range(1, n):
                if obstacleGrid[i][j] == 1:
                    dp[i][j] = 0
                else:
                    dp[i][j] = dp[i-1][j] + dp[i][j-1]
        return dp[-1][-1]

时间复杂度

• 时间复杂度：O(mn)
• 空间复杂度：O(mn)

最小路径和

问题描述

给定一个包含非负整数的 m x n 网格 grid，从左上角到右下角的路径使得路径上的数字总和最小。

示例：grid = [[1,3,1],[1,5,1],[4,2,1]]，输出：7。

思路分析

解决代码

class Solution:
    def minPathSum(self, grid: List[List[int]]) -> int:
        if not grid or not grid[0]:
            return 0
        rows = len(grid)
        cols = len(grid[0])
        for i in range(rows):
            for j in range(cols):
                if i == j == 0:
                    continue
                elif i == 0:
                    grid[i][j] = grid[i][j-1] + grid[i][j]
                elif j == 0:
                    grid[i][j] = grid[i-1][j] + grid[i][j]
                else:
                    grid[i][j] = min(grid[i-1][j], grid[i][j-1]) + grid[i][j]
        return grid[-1][-1]

时间复杂度

• 时间复杂度：O(mn)
• 空间复杂度：O(1)

转载地址：http://qugh.baihongyu.com/