经典动态规划例题整理（Python版）

由于本人的算法基础较为薄弱，所以在这里整理一下自己的做过的题，使自己能够随时随地回顾温习。

然后，本篇文章将会持续更新自己遇到的一些比较经典动态规划的题目，大家如果对代码有任何问题，直接在文章下面评论即可。我看到后会立刻回复。

 
 

1.我对动态规划的理解

网上对动态规划的介绍的文章已经很多了，那这里我还是要谈一下自己的理解，希望能够给大家带来一些灵感。

我所理解的动态规划，就两个词：动态、规划。动态我自己理解为：一个问题可以拆分为若干个子问题，然后通过逐步递推，得到最终的结果。规划就是最优问题，整体的最优细分到每个递推环节的最优。

然后，解决动态规划问题，最重要的可以发现其中的状态转移方程，我理解的状态转移方程的意思就是：一个通用的方程，即任意中间一个状态能够由前面的状态所推导得到。比如下图的dp[i][j]状态，就可以由左上的3个状态推导得到。

很多动态规划的问题，具体解法大多都是通过一个二维数组来存储中间环节的最优解。最后求二维数组中的最大值或者最后一个值。还有一种情况就是：如果当前状态只跟前面的一个状态有关，那么二维数组是可以优化为一维数组的，这样空间复杂度就由O(n²)优化为O(n)了。

 

 

2.例题整理

2.1 经典01背包问题

题目描述：一个人去偷东西，他的背包容量最大为20kg，然后有重量、价值不等的物品，比如重量为2、价值为3的物品，每件物品只能拿一件，求小偷能偷到的物品最大的价值。

"""
物品重量与价值对应关系：
w   v
2   3
3   4
5   8
9   10
背包容量：20
"""
import numpy as np
def func(pack, cap):
    max_value_arr = np.zeros([len(pack)+1, cap+1])
    # 第一列与第一排全为0，这样为后续能递推max_value_arr的值
    max_value_arr[:,0] = 0
    max_value_arr[0,:] = 0
    # i代表pack物品的序号
    for i in range(1, len(pack)+1):
        # j代表包中剩余的空间
        for j in range(1, cap+1):
            # 第一种情况，包中剩余空间不足
            if j < pack[i-1][0]:
                max_value_arr[i, j] = max_value_arr[i-1, j]
            # 第二种情况，包中空间足够
            else:
                # a代表放入当前物品后包中总价值，w是当前物品的所占空间
                w = pack[i-1][0]
                """
                下面这行是关键！！！为什么是i-1，这里必须用i-1才能推出当前的max_value_arr的值，
                然后再加上单独的value
                """
                a = max_value_arr[i-1, j-w] + pack[i-1][1]
                # b代表不放当前物品包中的总价值，两者求最大值
                b = max_value_arr[i-1, j]
                max_value_arr[i, j] = max(a, b)

    print(max_value_arr[-1, -1])


test_pack = [[2, 3],
             [3, 4],
             [4, 5],
             [5, 8],
             [9, 10]]
func(test_pack, 20)

 

2.2 最长公共子串

题目描述：a b两个字符串，求a b的最长公共子串。子串与子序列不同，子串必须是连续的，而子序列可以不连续。例如：

输入: a="abccbca"，b="bccca"
输出: 3
解释: 最长公共子序列就是"bcc"，为3

# 动态规划：只有当a[i-1]==b[j-1]时，子串长度才会在i-1与j-1的基础上+1
# 如果不同，则不变。用变量来记录表中最大的子串长度
a = "abccccdd"
b = "abcabcbbccs"
la = len(a)
lb = len(b)
res = [[0 for i in range(lb+1)] for j in range(la+1)]
mmax = 0
for i in range(1, la+1):
   for j in range(1, lb+1):
      if a[i-1] == b[j-1]:
         res[i][j] = res[i-1][j-1] + 1
         mmax = max(res[i][j], mmax)

print(mmax)

 

2.3 最长公共子序列（Leetcode1143）

题目描述：a b两个字符串，求a b的最长公共子序列。这里与上一题要区分开，重点是子序列可以是不连续的。

输入: a="abccbca"，b="bccca"
输出: 6
解释: 最长公共子序列就是"bccca"，为6

# 动态规划：相等就+1
# 如果不相等，则是max（a字符串少一个字符，b字符串少一个字符）
a = "abccccdd"
b = "abcabcbbcs"
la = len(a)
lb = len(b)
res = [[0 for i in range(lb+1)] for j in range(la+1)]
for i in range(1, la+1):
   for j in range(1, lb+1):
      if a[i-1] == b[j-1]:
         res[i][j] = res[i-1][j-1] + 1
      else:
         res[i][j] = max(res[i-1][j], res[i][j-1])

print(res[-1][-1])

 

2.4 最大子序和（Leetcode53）

题目描述：给定一个整数数组 nums ，找到一个具有最大和的连续子数组（子数组最少包含一个元素），返回其最大和。例如：

输入: [-2,1,-3,4,-1,2,1,-5,4],
输出: 6
解释: 连续子数组 [4,-1,2,1] 的和最大，为 6。

# 每项为：以此项为结尾的最大子序和
# 如果前一项的子序和<0，那么此项结尾的最大子序和就是本身
# 如果前一项的子序和>0，那么此项结尾的最大子序和就是前一项加上本身
def maxSubArray(nums):
    l = len(nums)
    res = [0 for i in range(l)]
    for i in range(l):
        if i == 0:
            res[i] = nums[i]
        else:
            if res[i - 1] <= 0:
                res[i] = nums[i]
            else:
                res[i] = nums[i] + res[i - 1]
    return max(res)

 

2.5 最长上升子序列（Leetcode300）

题目描述：给定一个无序的整数数组，找到其中最长上升子序列的长度。例如：

输入: [10,9,2,5,3,7,101,18]
输出: 4 
解释: 最长的上升子序列是 [2,3,7,101]，它的长度是 4。

# 最长上升子序列（动态规划）
# res[i]代表以此项为结尾的最大上升子序列的长度
# 关键是，拿当前值nums[i]与前面的值nums[j]相对比
# 如果比它大，那么就可以在res[j]的基础上加1。最后判断遍历完nums前j个元素后，加一的最大值，作为res[i]
def lengthOfLIS(nums):
    l = len(nums)
    if l == 0:
        return 0
    res = [1 for i in range(l)]
    for i in range(l):
        max_ = 1
        temp = 0
        for j in range(i):
            if nums[i] > nums[j]:
                temp = res[j] + 1
            if temp > max_:
                max_ = temp
        res[i] = max_

    return res

nums = [10,9,2,5,3,7,101,1]
print(lengthOfLIS(nums))
# 2，3，7，101 max为4

 

2.6 摆动序列（Leetcode376）

题目描述：如果连续数字之间的差严格地在正数和负数之间交替，则数字序列称为摆动序列。第一个差（如果存在的话）可能是正数或负数。少于两个元素的序列也是摆动序列。

给定一个整数序列，返回作为摆动序列的最长子序列的长度。 通过从原始序列中删除一些（也可以不删除）元素来获得子序列，剩下的元素保持其原始顺序。例如：

输入: [1,17,5,10,13,15,10,5,16,8]
输出: 7
解释: 这个序列包含几个长度为 7 摆动序列，其中一个可为[1,17,10,13,10,16,8]。

# 这题分为，如果上一次的摆动时正时，那么如果此次为负摆动的时候，最长摆动序列为上一次的最长摆动序列加1，
# 如果此次为正摆动或者没有摆动时，最长摆动序列就是上一次的最长摆动序列数；如果上一次摆动为负时，那么
# 如果此次为正摆动的时候，最长摆动序列为上一次的最长摆动序列加1，如果此次为负摆动或者没有摆动时，最长
# 摆动序列就是上一次的最长摆动序列数。用数组来记录这些上一次的最长摆动序列，方便以后使用。
test_list = [1, 17, 3, 20, 15, 6, 7, 8]
def swing(test):
    if len(test) < 2:
        return len(test)
    up = 1
    down = 1
    idx = 1
    n = len(test)
    while idx < n:
        if test[idx] > test[idx-1]:
            up = down + 1
        if test[idx] < test[idx-1]:
            down = up + 1
        idx += 1
    return max(up, down)

print(swing(test_list))

 

2.7 最小路径和（Leetcode64）

题目描述：给定一个包含非负整数的 m x n 网格，请找出一条从左上角到右下角的路径，使得路径上的数字总和为最小。注意：每次只能向下或者向右移动一步。

这个题很常见，面试经常被问到。

输入:
[
  [1,3,1],
  [1,5,1],
  [4,2,1]
]
输出: 7
解释: 因为路径 1→3→1→1→1 的总和最小。

def minPathSum(grid):
    for i in range(len(grid)):
        for j in range(len(grid[0])):
            if i == j == 0: 
                continue
            elif i == 0:  
                grid[i][j] = grid[i][j - 1] + grid[i][j]
            elif j == 0:  
                grid[i][j] = grid[i - 1][j] + grid[i][j]
            else: 
                grid[i][j] = min(grid[i - 1][j], grid[i][j - 1]) + grid[i][j]
    return grid[-1][-1]

 

持续更新中……