动态规划专题

最新推荐文章于 2024-04-15 20:01:47 发布

KazeHelloWorld

最新推荐文章于 2024-04-15 20:01:47 发布

阅读量226

点赞数

分类专栏：动态规划算法

本文链接：https://blog.csdn.net/KazeHelloWorld/article/details/118862547

版权

算法同时被 2 个专栏收录

12 篇文章 0 订阅

订阅专栏

动态规划

7 篇文章 0 订阅

订阅专栏

动态规划

139.单词拆分

给定一个非空字符串 s 和一个包含非空单词的列表 wordDict，判定 s 是否可以被空格拆分为一个或多个在字典中出现的单词。

说明：

拆分时可以重复使用字典中的单词。
你可以假设字典中没有重复的单词。

class Solution:
    def wordBreak(self, s: str, wordDict: List[str]) -> bool:
        dp = [False]*(len(s)+1)
        dp[0] = True
        for i in range(len(s)):
            for j in range(i + 1):
                if dp[j] and s[j:i+1] in wordDict:
                    dp[i + 1] = True
                    break 
        return dp[-1]

42.接雨水

给定 n 个非负整数表示每个宽度为 1 的柱子的高度图，计算按此排列的柱子，下雨之后能接多少雨水。

在这里插入图片描述
动态规划：
两个数组保存对应位置往左和往右的最大高度，然后遍历高度数组，找到低的那个最大高度，减去当前位置高度得到结果。

class Solution:
    def trap(self, height: List[int]) -> int:
        if not height:
            return 0
        n = len(height)
        left_max, right_max = [0] * n, [0] * n
        left_max[0] = height[0]
        right_max[-1] = height[-1]
        ans = 0
        for i in range(1, n):
            left_max[i] = max(height[i], left_max[i - 1])
        for i in range(n - 2, -1, -1):
            right_max[i] = max(height[i], right_max[i + 1])
        for i in range(n):
            ans += min(left_max[i], right_max[i]) - height[i]
        return ans

左右指针：
左右两个指针，更新更小的位置，如果当前高度比max大，更新max，否则计算ans
每次更新时当前位置的最大值是左右两边最大的较小值，所以直接用一边的max减，每次遇到比max大，只更新，因为左边兜不住。
因为每次左边更新时右边的数组值一定比当前位置大，而且left_max存储的值也一定比right_max小，因为如果left-max比右边所有值都大，就会继续更新右边不会走到左边来。

class Solution:
    def trap(self, height: List[int]) -> int:
        n = len(height)
        left_max = right_max = ans = 0
        left, right = 0, n - 1
        while left <= right:
            if height[left] < height[right]:
                if height[left] > left_max:
                    left_max = height[left]
                else:
                    ans += left_max - height[left]
                left += 1
            else:
                if height[right] > right_max:
                    right_max = height[right]
                else:
                    ans += right_max - height[right]
                right -= 1
        return ans

413.等差数列划分

如果一个数列至少有三个元素，并且任意两个相邻元素之差相同，则称该数列为等差数列。

动态规划：
dp数组保存以当前位置i为末尾的数列为等差数列的个数，因为每次相对于前一位置，多了一个三个数长度的数组，所以每次+1，最后求和得到结果。

class Solution:
    def numberOfArithmeticSlices(self, nums: List[int]) -> int:
        n = len(nums)
        dp = [0] * n 
        for i in range(2, n):
            if (nums[i-1] - nums[i - 2] == nums[i] - nums[i - 1]):
                dp[i] = dp[i - 1] + 1
        return sum(dp)

优化：
滚动数组优化空间

class Solution:
    def numberOfArithmeticSlices(self, nums: List[int]) -> int:
        n = len(nums)
        ans = dp = 0
        for i in range(2, n):
            if (nums[i-1] - nums[i - 2] == nums[i] - nums[i - 1]):
                dp = dp + 1
                ans += dp
            else:
                dp = 0
        return ans

91.解码方法

一条包含字母 A-Z 的消息通过以下映射进行了编码：

‘A’ -> 1
‘B’ -> 2
…
‘Z’ -> 26
要解码已编码的消息，所有数字必须基于上述映射的方法，反向映射回字母（可能有多种方法）。例如，“11106” 可以映射为：

“AAJF” ，将消息分组为 (1 1 10 6)
“KJF” ，将消息分组为 (11 10 6)
注意，消息不能分组为 (1 11 06) ，因为 “06” 不能映射为 “F” ，这是由于 “6” 和 “06” 在映射中并不等价。

给你一个只含数字的非空字符串 s ，请计算并返回解码方法的总数。

题目数据保证答案肯定是一个 32 位的整数。

动态规划：
若当前位置两位为9到27之间，则加上dp[i-2]，若当前位置不为0，则加上dp[i-1]

class Solution:
    def numDecodings(self, s: str) -> int:
        n = len(s)
        dp = [0] * (n + 1)
        dp[0], dp[1] = 1, int(s[0] != '0')
        for i in range(2, n + 1):
            if s[i - 2] != '0' and 9 < int(s[i - 2: i]) < 27:
                dp[i] += dp[i - 2]
            if s[i - 1] != '0':
                dp[i] += dp[i - 1]
        return dp[-1]

优化：

class Solution:
    def numDecodings(self, s: str) -> int:
        n = len(s)
        pre, cur = 1, int(s[0] != '0')
        for i in range(2, n + 1):
            tmp = 0
            if s[i - 2] != '0' and 9 < int(s[i - 2: i]) < 27:
                tmp = pre
            if s[i - 1] != '0':
                tmp += cur
            cur, pre = tmp, cur
        return cur

96.不同的二叉搜索树

给你一个整数 n ，求恰由 n 个节点组成且节点值从 1 到 n 互不相同的二叉搜索树有多少种？返回满足题意的二叉搜索树的种数。

假设 n 个节点存在二叉排序树的个数是 G (n)，令 f(i) 为以 i 为根的二叉搜索树的个数，则
$G (n) = f (1) + f (2) + f (3) + f (4) + . . . + f (n)$

当 i 为根节点时，其左子树节点个数为 i-1 个，右子树节点为 n-i，则

$f (i) = G (i - 1) * G (n - i) f (i) = G (i - 1) * G (n - i)$

综合两个公式可以得到卡特兰数公式
$G (n) = G (0) * G (n - 1) + G (1) * (n - 2) + . . . + G (n - 1) * G (0) G (n)$

class Solution:
    def numTrees(self, n: int) -> int:
        dp = [0] * (n + 1)
        dp[0], dp[1] = 1, 1
        for i in range(2, n + 1):
            for j in range(1, i + 1):
                dp[i] += dp[j - 1] * dp[i - j]
        return dp[-1]

931.下降路径最小和

给你一个 n x n 的方形整数数组 matrix ，请你找出并返回通过 matrix 的下降路径的最小和。

下降路径可以从第一行中的任何元素开始，并从每一行中选择一个元素。在下一行选择的元素和当前行所选元素最多相隔一列（即位于正下方或者沿对角线向左或者向右的第一个元素）。具体来说，位置 (row, col) 的下一个元素应当是 (row + 1, col - 1)、(row + 1, col) 或者 (row + 1, col + 1) 。

思路： 从下到上依次加上可以得到的最小值，边界上用min和max处理。

class Solution:
    def minFallingPathSum(self, matrix: List[List[int]]) -> int:
        while len(matrix) >= 2:
            cur = matrix.pop()
            matrix[-1] = [ matrix[-1][i] + min(cur[max(0, i - 1): min(i + 2, len(cur))]) for i in range(len(cur))]
        return min(matrix[0])

120.三角形最短路径和

给定一个三角形 triangle ，找出自顶向下的最小路径和。

每一步只能移动到下一行中相邻的结点上。相邻的结点在这里指的是下标与上一层结点下标相同或者等于上一层结点下标 + 1 的两个结点。也就是说，如果正位于当前行的下标 i ，那么下一步可以移动到下一行的下标 i 或 i + 1 。

类似上题

class Solution:
    def minimumTotal(self, triangle: List[List[int]]) -> int:
        while len(triangle) >= 2:
            cur = triangle.pop()
            triangle[-1] = [triangle[-1][i] + min(cur[i: min(i + 2, len(cur))]) for i in range(len(triangle[-1]))]
        return triangle[0][0]

1314. 矩阵区域和

给你一个 m x n 的矩阵 mat 和一个整数 k ，请你返回一个矩阵 answer ，其中每个 answer[i][j] 是所有满足下述条件的元素 mat[r][c] 的和：

i - k <= r <= i + k,
j - k <= c <= j + k 且
(r, c) 在矩阵内。

利用前缀和数组计算。

class Solution:
    def matrixBlockSum(self, mat: List[List[int]], k: int) -> List[List[int]]:
        m, n = len(mat), len(mat[0])
        proSum = [[0] * (n + 1) for _ in range(m + 1)]
        for i in range(1, m + 1):
            for j in range(1, n + 1):
                proSum[i][j] = proSum[i-1][j] + proSum[i][j-1] - proSum[i-1][j-1] + mat[i - 1][j - 1]
        def get(i, j):
            i, j = max(0, min(i, m)), max(0, min(j, n))
            return proSum[i][j]
        
        for i in range(m):
            for j in range(n):
                mat[i][j] = get(i+k+1, j+k+1) - get(i-k, j+k+1) - get(i+k+1, j-k) + get(i-k, j-k)
        return mat