【力扣十道】dp动态规划

阿栗要努力

已于 2022-02-22 21:30:33 修改

阅读量102

点赞数

分类专栏： leetcode 文章标签：动态规划算法 leetcode python

于 2021-06-13 17:34:10 首次发布

本文链接：https://blog.csdn.net/qq_40664172/article/details/117878278

版权

leetcode 专栏收录该内容

9 篇文章 0 订阅

订阅专栏

博主分享了自己在解决动态规划和滑动窗口问题上的经验，通过解析几道经典的算法题，如打家劫舍、不同路径、不同路径II等，详细介绍了动态规划的解题思路。在动态规划中，博主强调了局部最优解的重要性，并给出了初始化dp数组和计算局部最大值的步骤。此外，还涉及了滑动窗口在特定问题中的应用。博客结尾，博主表达了对算法学习的热情，计划每周投入时间深入学习。

摘要由CSDN通过智能技术生成

虽然树递归什么的我放弃了，很烦，但是来写dp了，就熬着呗，煎和熬都是变美味的方法

dp对我来说也是三步：

建dp数组初始化下标0的位置
!!!不要看全局，把自己放在j这个位置想当前的局部最大该怎么算
返回最大值

198. 中等-打家劫舍
 213.中等-打家劫舍II
把环拆开，劫他们两次

哭哭不敢写树状dp，再写两道普通的再树状

62. 不同路径
你就想你站在i,j的最多路径怎么算啊，不要想全局啊不要想全局

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

感觉跟字节的第二题有些像，我们试着解一下
在这里插入图片描述

class Solution:
    def uniquePaths(self, m: int, n: int) -> int:
        m = 30
        n = 30
        dx = 6
        dy = 6
        bx = 4
        by = 3#这边是憋住，如果没有的话结果会是6
        dp = [[0]*n for i in range(m)]
        for i in range(m):
            for j in range(n):
                if i == 0 and j == 0:
                    dp[i][j] = 1
                elif i == 0:
                    dp[i][j] = 0
                elif j == 0 :
                    dp[i][j] = 0 
                elif i-1 == bx and j-1 == by:
                    dp[i][j] = dp[i][j]
                else:
                    dp[i][j] += dp[i-2][j-1]+dp[i-1][j-2]
                if i == dx and j == dy:
                    return dp[dx][dy]

开心～～🎉今天不管结果怎么样能多写几道动态规划和滑动窗口已经很满足了，以后可以每周拿出一天畅游算法芜湖～

63. 中等：不同路径 II
如果题目限制了只能左下某个方向，那么我们的思路模版可以是初始化左边和上边，然后再循环走

class Solution:
    def uniquePathsWithObstacles(self, obstacleGrid: List[List[int]]) -> int:
        m = len(obstacleGrid)# hang
        n = len(obstacleGrid[0]) #lie
        dp = [[0]*n for i 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 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[m-1][n-1]

688. 骑士在棋盘上的概率
说是简单题

class Solution:
    def knightProbability(self, n: int, k: int, row: int, column: int) -> float:
        dp =[[[0] * n for i in range(n)] for j in range(k+1)]
        time = 0
        while time <= k :
            for i in range(n):
                for j in range(n):
                    if time == 0:
                        dp[0][i][j] = 1
                    else:
                        for x,y in [[2,1],[1,2],[-2,1],[-1,2],[2,-1],[1,-2],[-2,-1],[-1,-2]]:
                            nx, ny = i+x, j+y
                            if 0 <= nx < n and 0 <= ny < n:
                                dp[time][i][j] = dp[time][i][j] + dp[time - 1][nx][ny] /8
            time += 1 
        return dp[k][row][column]