python 动态规划总结及相关力扣题目

大部分内容和例子均来自 骆昊老师知乎文章 : 透过面试说算法(4) - 动态规划

1. 分治法和动态规划的区别

动态规划和之前文章中讲到的分治法的区别。分治法要解决的子问题是相互独立的，可以分别进行求解；而动态规划要解决的子问题是有重叠的，所以可以通过记忆化技术把已解决问题的结果保存起来。使用动态规划可以让很多问题的时间复杂度从指数级降到 $O(N^3)$ 、 $O(N^2)$ 甚至是 $O(N)$ 。

2. 什么问题适合使用动态规划解决

如果想知道一个问题适不适合用动态规划来解决，可以看看问题是否符合以下两条性质：

具备最优子结构：整个问题的最佳解法可以由各个子问题的最佳解法构成。

具备相互重叠子问题：子问题会反复出现。

2. 动态规划通常会包含两个环节：

1. 递归：求解子问题。

我的Python 递归总结

2. 记忆化：把已经计算出的结果保存起来。

3. 题目应用：

输入两个字符串，求最长公共子序列（LCS，Longest Common Subsequence）的长度。

题目参考理解1
题目参考理解2

公式：

def lcs_n(a,b):
    if a == '' or b == '':
        return 0
    if a[0] == b[0]:
        return lcs_n(a[1:],b[1:])+1
    else:
        one = lcs_n(a[1:],b)
        two = lcs_n(a,b[1:])
        return max(one,two)

验证：

a = 'BDCABA'
b = 'ABCBDAB'

res = lcs_n(a,b)
print(res)

虽然问题解决，但是时间复杂度特别高，其渐近时间复杂度为 $(2^M+2^N)$ 。可能大家已经注意到了，上面的算法再计算公共子序列长度时存在大量的重复运算，跟斐波那契数列优化前的代码是一样的。既然如此我们就可以考虑用动态规划的思路，通过保存中间运算结果对代码加以优化。

def lcs(a, b):
    matrix = [[0] * (len(b) + 1) for _ in range(len(a) + 1)]
    for i in range(1, len(a) + 1):
        for j in range(1, len(b) + 1):
            if a[i - 1] == b[j - 1]:
                matrix[i][j] = matrix[i - 1][j - 1] + 1
            else:
                matrix[i][j] = max(matrix[i - 1][j], matrix[i][j - 1])
    return matrix[-1][-1]

上面算法的渐近时间复杂度为 $ O( M * N)$，也可以利用functools里的装饰器lru_cache 添加记忆

import functools
@functools.lru_cache(maxsize=None)

def lcs_n(a,b):
    if a == '' or b == '':
        return 0
    if a[0] == b[0]:
        return lcs_n(a[1:],b[1:])+1
    else:
        one = lcs_n(a[1:],b)
        two = lcs_n(a,b[1:])
        return max(one,two)

a = 'BDCABA'
b = 'ABCBDAB'

res = lcs_n(a,b)
print(res) # 4

对于一个有 $N$ 个整数的列表，找出它的子列表元素之和的最大值。

方法一：使用二重循环来找出这个子列表和的最大值，代码如下所示，渐近时间复杂度为 $O(N^2)$。

items = list(map(int, input().split()))
max_sum = items[0]
for i in range(len(items)):
    cur_sum = 0
    for item in items[i:]:
        cur_sum += item
        if max_sum < cur_sum:
            max_sum = cur_sum
print(max_sum)

# 1 -2 3 5 -3 2 # 8
# 0 -2 3 5 -1 2 # 9
# -9 -2 -3 -5 -3 # -2

items = list(map(int,input().split()))
overall = partial = items[0]
for i in range(1,len(items)):
    partial = max(items[i],partial+items[i])
    overall = max(overall,partial)
print(overall)

# 1 -2 3 5 -3 2 # 8
# 0 -2 3 5 -1 2 # 9
# -9 -2 -3 -5 -3 # -2

力扣 1035 不相交的线（lcs问题）

问题描述：

class Solution:
    def maxUncrossedLines(self, nums1: List[int], nums2: List[int]) -> int:
        len1,len2 = len(nums1),len(nums2)
        matrix = [[0] * (len2 + 1) for _ in range(len1 + 1)]
        for i in range(1,len1 + 1):
            for j in range(1,len2 +1):
                if nums1[i-1]==nums2[j-1]:
                    matrix[i][j] = matrix[i-1][j-1] +1
                else:
                    matrix[i][j] = max(matrix[i-1][j],matrix[i][j-1])
        return matrix[-1][-1]

力扣 322 零钱兑换

| 题目；

| 方法一：带memory的递归

import functools
class Solution:
    def coinChange(self, coins, amount: int):
        @functools.lru_cache(maxsize=None)
        def dp(n):
            res = float("inf")
            if n < 0 : return -1
            if n == 0: return 0
            for coin in coins:
                subproblem = dp(n-coin)
                if subproblem == -1:continue
                res = min(res,1+dp(n-coin))
            return res if res!=float("inf") else -1
        return dp(amount)

** | 方法二：动态规划**
对于动态规划的理解
题目详解

class Solution:
    def coinChange(self, coins:List, amount: int):
        dp = [0] + [10001]*amount # 0 <= amount <= 10^4
        for coin in coins:
            for j in range(coin,amount+1):
                dp[j] = min(dp[j] , dp[j-coin] + 1 )
        return dp[amount] if dp[amount]!= 10001 else -1 

力扣 53. 最大连续子数组和

题目：

题目解析：参考解析地址

在写状态转移方程的时候会遇到，经过一个数的最大连续子数组的最大和是多少，但这样很难写出状态转移方程，因为子问题很难划分。现在我们换一种角度考虑该问题：以这个数字结尾的最大子序列之和是多少，此时子问题便很好确定：

dp = [0] * len(nums)

我们的问题转化为了，确定并存储每一个，以nums[i]结尾的最大连续子序列之和。
其中：$dp[0]=nums[0]$
如果 $dp[i-1]<0$ , 那么 $dp[i]=nums[i]$ , 否则 $dp[i]=dp[i-1]+nums[i]$

取最大的dp值即得到最终结果：

class Solution:
    def maxSubArray(self, nums: List[int]) -> int:
        size = len(nums)
        if size == 0:
            return 0
        dp = [0]*size
        dp[0] = nums[0]
        for i in range(1,size):
            if dp[i-1] >= 0:
                dp[i] = dp[i-1] + nums[i]
            else:
                dp[i] = nums[i]
        return max(dp)

解法二：分治法 (直接贴了答案，待后续自己继续推敲)

说起分治法，首先想到了归并排序算法

根据「状态转移方程」，$p[i]$ 的值只和 $dp[i-1]$ 有关，因此可以使用「滚动变量」的方式将代码进行优化。

from typing import List


class Solution:
    def maxSubArray(self, nums: List[int]) -> int:
        size = len(nums)
        if size == 0:
            return 0
        return self.__max_sub_array(nums, 0, size - 1)

    def __max_sub_array(self, nums, left, right):
        if left == right:
            return nums[left]
        mid = (left + right) >> 1
        return max(self.__max_sub_array(nums, left, mid),
                   self.__max_sub_array(nums, mid + 1, right),
                   self.__max_cross_array(nums, left, mid, right))

    def __max_cross_array(self, nums, left, mid, right):
        # 一定包含 nums[mid] 元素的最大连续子数组的和，
        # 思路是看看左边"扩散到底"，得到一个最大数，右边"扩散到底"得到一个最大数
        # 然后再加上中间数
        left_sum_max = 0
        start_left = mid - 1
        s1 = 0
        while start_left >= left:
            s1 += nums[start_left]
            left_sum_max = max(left_sum_max, s1)
            start_left -= 1

        right_sum_max = 0
        start_right = mid + 1
        s2 = 0
        while start_right <= right:
            s2 += nums[start_right]
            right_sum_max = max(right_sum_max, s2)
            start_right += 1
        return left_sum_max + nums[mid] + right_sum_max