代码随想录算法训练营第三十四天|leetcode62.不同路径、leetcode 63. 不同路径 II

1 leetcode62.不同路径

题目链接：62. 不同路径 - 力扣（LeetCode）

文章链接：代码随想录

视频链接：动态规划中如何初始化很重要！| LeetCode：62.不同路径_哔哩哔哩_bilibili

思路：首先就不知道dp的含义应该如何定义了

1.1 视频后的思路

动态规划五部曲：

1. dp[i][j]的含义是表示第i行第j列的格子的方法和
2. 动态规划的表达式：这个格子的和和哪些值有关呢，首先是他的上面一个格子和左边格子的数有关，即二者相加即可
3. 初始值的定义：就是确定哪些是固定的，就是第一行和第一列的数值，因为这两个数值不管怎么走都只有一种方法
4. 确定遍历顺序：就是遍历每一个格子的方法
5. 打印dp值：演示的时候可以打印

class Solution:
    def uniquePaths(self, m: int, n: int) -> int:
        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[m-1][n-1]

1.2 递归的方法

其实看了思路以后发现这个也很简单

class Solution:
    def uniquePaths(self, m: int, n: int) -> int:
        if m == 1 or n == 1:
            return 1
        return self.uniquePaths(m-1,n)+self.uniquePaths(m,n-1)

1.3 本题小结

1. 这道题目主要是没想到其值和格子的位置有关，没有找到这个规律
2. dp[i]的值如何确定在动态规划中非常重要，这个值确实很多时候很难想到

2 leetcode 63. 不同路径 II

题目链接：63. 不同路径 II - 力扣（LeetCode）

文章链接：代码随想录

视频链接：动态规划，这次遇到障碍了| LeetCode：63. 不同路径 II_哔哩哔哩_bilibili

思路：跟上一题差不多吧，但是我写的代码只能满足部分测试集的要求，没有办法满足全部的测试集数据

2.1 自己的方法

虽然在[[0]]这种情况下报错了，但是还是记录一下自己的方法，后来发现改了很多还都挺有问题的，换个角度吧，看视频

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

2.2 视频后更正

真的就是懒会出问题，其实定义一个同样长度的二维数组问题就解决了，，，

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

2.3 本题小结

1. 其实这道题建立一个新的二维数组问题全都解决了，我就是在那儿倔强，不建立，就一直是全局解，找不到最优解，看来不能偷懒
2. 这道题真的就和上面一道一模一样，就是不要乱加，加多了反而会犯错

3 今日小结

1. 这两道题难度，首先就是dp[i]的定义，对于这种定义问题确实对我而言有些难想，希望做多了我会变得更好吧
2. 第二题，真的与其在原二维数组混乱，不如直接新建一个统计，更加明确这个值
3. 希望以后我的思路会越来越清晰