力扣Day39（2.26）| 第八章 动态规划 （ 62. 不同路径 63. 不同路径 II ）

题一：62. 不同路径

链接

题目链接：
视频链接：
文章链接：

视频总结

编程思路

Me：

1. 二维数组定义

力扣实战

思路一：dp

 class Solution:
    def uniquePaths(self, m: int, n: int) -> int:
        # 想好初始是什么，然后想递归
        dp = [[1 for i in range(n)] for j in range(m)]  #二维定义，背一下！
        # dp[i][j]=dp[i-1][j]+dp[i][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]

 class Solution:
    def uniquePaths(self, m: int, n: int) -> int:
        # 想好初始是什么，然后想递归
        dp = [1]*n
        # dp[i][j]=dp[i-1][j]+dp[i][j-1]    #二维的在初始化数组时有点麻烦，得学
        for i in range(1,m):
            for j in range(1,n):
                dp[j]=dp[j]+dp[j-1]
        return dp[-1]
       
# 反思1：

思路二：dfs

	#dfs方法，会超时
 class Solution:
    def uniquePaths(self, m: int, n: int) -> int:
        # dfs 方法
        def func(i,j,m,n):
            if i>m or j>n:
                return 0
            if i==m and j==n:
                return 1
            down = func(i+1,j,m,n)
            right = func(i,j+1,m,n)
            return down + right
        res=func(1,1,m,n)
        return res

题二：63. 不同路径 II

链接

题目链接：
视频链接：
文章链接：

视频总结

关键点

1. 初始化不一样，行列有一个为障碍，其他的都得为0

编程思路

力扣实战

思路一：

 class Solution:
    def uniquePathsWithObstacles(self, obstacleGrid: List[List[int]]) -> int:
        #在62题的基础上考虑了有障碍的情况，举例发现，有障碍是，相当于dp=0且障碍 在第一行和第一列需单独考虑
        m = len(obstacleGrid)
        n = len(obstacleGrid[0])
        if n==1 and m==1:
            return (1-obstacleGrid[0][0])
        
        dp = [0]*n
        for j in range(0,n):	
            if obstacleGrid[0][j]!=1:	#不是障碍的地方都为dp唯一，表示一种方法过去
                dp[j]=1
            else:
                break	#是障碍的地方，过不去，且后面的地方都过不去，所以都为0
        for i in range(1,m):
            if  obstacleGrid[i][0]==1:	#每一列的起始处先判断是否为零
                dp[0]=0
            for j in range(1,n):
                if obstacleGrid[i][j]==1:	#数组值为1，则对应位置的dp为零，
                    dp[j]=0
                else:
                    dp[j]=dp[j]+dp[j-1]
        return dp[-1]
        
#卡尔写法：创建0的方式和初始化的写法可学
class Solution:
    def uniquePathsWithObstacles(self, obstacleGrid: List[List[int]]) -> int:
        # 构造一个DP table
        row = len(obstacleGrid)
        col = len(obstacleGrid[0])
        dp = [[0 for _ in range(col)] for _ in range(row)]
        dp[0][0] = 0 if obstacleGrid[0][0] == 1 else 1
        if dp[0][0] == 0:
            return 0  # 如果第一个格子就是障碍，return 0
        # 第一行
        for i in range(1, col):
            if obstacleGrid[0][i] == 1:
                # 遇到障碍物时，直接退出循环，后面默认都是0
                break
            dp[0][i] = 1

        # 第一列
        for i in range(1, row):
            if obstacleGrid[i][0] == 1:
                # 遇到障碍物时，直接退出循环，后面默认都是0
                break
            dp[i][0] = 1
        # print(dp)

        for i in range(1, row):
            for j in range(1, col):
                if obstacleGrid[i][j] == 0:
                    dp[i][j] = dp[i - 1][j] + dp[i][j - 1]
        return dp[-1][-1]

思路二：

 class Solution:
    def uniquePathsWithObstacles(self, obstacleGrid: List[List[int]]) -> int:
        #还是二维dp数组丝滑
        m = len(obstacleGrid)
        n = len(obstacleGrid[0])
        dp=[[0 for i in range(n)] for j in range(m)]
        for i in range(n):
            if obstacleGrid[0][i]==0:
                dp[0][i]=1
            else:
                break
        for j in range(m):
            if obstacleGrid[j][0]==0:
                dp[j][0]=1
            else:
                break
        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]        


class Solution:
    """
    使用一维dp数组
    """

    def uniquePathsWithObstacles(self, obstacleGrid: List[List[int]]) -> int:
        m, n = len(obstacleGrid), len(obstacleGrid[0])

        # 初始化dp数组
        # 该数组缓存当前行
        curr = [0] * n
        for j in range(n):
            if obstacleGrid[0][j] == 1:
                break
            curr[j] = 1
            
        for i in range(1, m): # 从第二行开始
            for j in range(n): # 从第一列开始，因为第一列可能有障碍物
                # 有障碍物处无法通行，状态就设成0
                if obstacleGrid[i][j] == 1:
                    curr[j] = 0
                elif j > 0:
                    # 等价于
                    # dp[i][j] = dp[i - 1][j] + dp[i][j - 1]
                    curr[j] = curr[j] + curr[j - 1]
                # 隐含的状态更新
                # dp[i][0] = dp[i - 1][0]
        
        return curr[n - 1]

文档总结

1. 不同的写法，可学习