DP 动态规划算法 (Python3)

Posted 2021-04-06 蒋春生

前言

我们遇到的问题中，有很大一部分可以用动态规划(简称DP)来解决。

解决这类问题可以很大的提升你的能力和技巧，我会试着帮助你理解如何使用DP来解题。

这篇文章是基于实例来开讲的，因为干巴巴的理论不好理解。

注意⚠️：描述比较多 要有耐心。

简介

一、什么是动态规划，我们如何描述它

动态规划算法通常基于一个递推公式及一个或多个初始状态。

当前子问题的解 将由上一个子问题的解推出。

使用动态规划解题只需要多项式时间时间复杂度，因为它比回溯法，暴力法等快许多。

现在我们通过一个例子了解DP的基本原理。

首先，我们要找到某个状态的最优解，然后在它的帮助下，找到下一个状态的最优解。

二、"状态" 代表什么及如何找到它？

“状态” 用来描述该问题的子问题的解。

例子:

如果我们有 1元，3元，5元，的硬币n个，若何用最少的硬币凑够11元呢？

表面上这道题可以用贪心算法，但是贪心算法无法保证可以求解，比如一元换成2元的时候

首先我们思考一个问题，如何用最少的硬币凑够i元(i<11)? 为什么要问这个问题呢？俩个原因。

1. 当我们遇到一个问题时，总是习惯把问题的规模变小，这样便于分析讨论。
2. 这个规模变小后的问题和原来的问题同质，除了规模变小，其他的都本质是一样的，本质上它还是同一个问题(规模变小后的问题其实是原问题的子问题)。

好了 让我们从最小的i开始吧。

当i=0,即我们需要多少个硬币来凑够0元。由于1，3，5都大于0，即没有比0小的值，因此凑够0元我们需要0个硬币。(这个分析是不很傻，别着急，这个思路有利于我们理清动态规则究竟在做些什么。)

这个时候我们发现用一个标记来这句 "凑够0元我们需要0个硬币"。会比较方便，如果一直用纯文字来表述，不出一会就觉得很绕了。于是我们以及得到了 d(0)=0,表示凑够0元最小需要0个硬币，当i=1时，只要面值为1元可用，因此我们拿起一个面值为1的硬币，接下来只需要凑够0元即可，而这个时候我们已经知道答案的，d(0)=0。所以

d(1) = d(1-1)+1
d(1) = d(0)+1
d(1) = 0+1 
d(1) = 1

当i = 2,仍然只需要有面值为1的硬币可用，于是我拿起一个一个面值为1的硬币，接下来我只需要凑够2-1=1即可(记得要用最下的硬币数量)，而这个答案也已经知道了。所以

d(2) = d(2-1)+1 = d(1)+1 = 1+1 = 2

一直到这里,你都觉的好无聊，感觉小学生做题目似的。因为我们只能操作面值为1的硬币了 ，耐心点，让我们看看i=3时，我们能用的硬币就有两种了1元=和3元的(5元的仍然没用，因为您需要凑的数目是3元！5元太多了。)

既然有能用的硬币有两种，我就两种方案。如果我就拿了一元的硬币，我的目标就变了：

凑够3-1=2需要最少的硬币数量
d(3) = d(3-1)+1 = d(2)+1 = 2+1 = 3

这个方案说的是，我拿3个一元的硬币；第二种方案就是拿起一个3元的硬币我的目标变了：

凑够3-1=2元需要最少的硬币数量
d(3) = d(3-3)+1 = d(0)+1 = 0+1 = 1

好了，这两种方案那种更优呢？我记得我们可是要用在最少的硬币的老凑够3元，所以，选择· 的d(3)=1。具体怎么样得到的呢：

d(3) = min{d(3-1)+1,d(3-3)+1}。

ok ，码了这么多字讲具体的东西，让我们来点抽抽象的。从以上的文字中，我们要抽出动态规则里非常重要的两个概念：状态和状态转移方程。

上文中d(i)表示凑够i元需要的最少硬币数量，我们将它定义为该问题的”状态”， 这个状态是怎么找出来的呢？

根据子问题定义状态。你找到子问题，状态也就浮出水面了。最终我们要求解的问题，可以用这个状态来表示：d(11)，即凑够11元最少需要多少个硬币。那状态转移方程是什么呢？既然我们用d(i)表示状态，那么状态转移方程自然包含d(i)， 上文中包含状态d(i)的方程是：d(3)=min{d(3-1)+1, d(3-3)+1}。没错， 它就是状态转移方程，描述状态之间是如何转移的。当然，我们要对它抽象一下，

d(i)=min{ d(i-vj)+1 }，其中i-vj >=0，vj表示第j个硬币的面值;

有了状态和状态转移方程，这个问题基本上也就解决了。当然了，Talk is cheap,show me the code!

伪代码如下：

Min = [x for x in range(12)]
VN = [1, 3, 5]
for i in range(1, 12, 1):
    for j in range(3):
        if VN[j] <= i and Min[i - VN[j]] + 1 < Min[i]:
            Min[i] = Min[i - VN[j]] + 1


print(Min[1::1])

下图是当i从0到11时的解：

img

从上图可以得出，要凑够11元至少需要3枚硬币。

此外，通过追踪我们是如何从前一个状态值得到当前状态值的， 可以找到每一次我们用的是什么面值的硬币。比如，从上面的图我们可以看出， 最终结果d(11)=d(10)+1(面值为1)，而d(10)=d(5)+1(面值为5)，最后d(5)=d(0)+1 (面值为5)。所以我们凑够11元最少需要的3枚硬币是：1元、5元、5元。

注意：原文中这里本来还有一段的，但我反反复复读了几遍， 大概的意思我已经在上文从i=0到i=3的分析中有所体现了。作者本来想讲的通俗一些， 结果没写好，反而更不好懂，所以这段不翻译了。

三、初级

上面讨论了一个非常简单的例子。现在让我们来看看对于更复杂的问题， 如何找到状态之间的转移方式(即找到状态转移方程)。为此我们要引入一个新词叫递推关系来将状态联系起来(说的还是状态转移方程)

OK，上例子，看看它是如何工作的。

一个序列有N个数：A[1],A[2],…,A[N]，求出最长非降子序列的长度。(讲DP基本都会讲到的一个问题LIS：longest increasing subsequence)

正如上面我们讲的，面对这样一个问题，我们首先要定义一个“状态”来代表它的子问题， 并且找到它的解。注意，大部分情况下，某个状态只与它前面出现的状态有关， 而独立于后面的状态。

让我们沿用“入门”一节里那道简单题的思路来一步步找到“状态”和“状态转移方程”。假如我们考虑求A[1],A[2],…,A[i]的最长非降子序列的长度，其中i<N， 那么上面的问题变成了原问题的一个子问题(问题规模变小了，你可以让i=1,2,3等来分析) 然后我们定义d(i)，表示前i个数中以A[i]结尾的最长非降子序列的长度。OK， 对照“入门”中的简单题，你应该可以估计到这个d(i)就是我们要找的状态。如果我们把d(1)到d(N)都计算出来，那么最终我们要找的答案就是这里面最大的那个。状态找到了，下一步找出状态转移方程。

为了方便理解我们是如何找到状态转移方程的，我先把下面的例子提到前面来讲。如果我们要求的这N个数的序列是：

5，3，4，8，6，7

根据上面找到的状态，我们可以得到：（下文的最长非降子序列都用LIS表示）

• 前1个数的LIS长度d(1)=1(序列：5)
• 前2个数的LIS长度d(2)=1(序列：3；3前面没有比3小的)
• 前3个数的LIS长度d(3)=2(序列：3，4；4前面有个比它小的3，所以d(3)=d(2)+1)
• 前4个数的LIS长度d(4)=3(序列：3，4，8；8前面比它小的有3个数，所以 d(4)=max{d(1),d(2),d(3)}+1=3)

OK，分析到这，我觉得状态转移方程已经很明显了，如果我们已经求出了d(1)到d(i-1)， 那么d(i)可以用下面的状态转移方程得到：

d(i) = max{1, d(j)+1},其中j<i,A[j]<=A[i]

用大白话解释就是，想要求d(i)，就把i前面的各个子序列中， 最后一个数不大于A[i]的序列长度加1，然后取出最大的长度即为d(i)。当然了，有可能i前面的各个子序列中最后一个数都大于A[i]，那么d(i)=1， 即它自身成为一个长度为1的子序列。

分析完了，上图：(第二列表示前i个数中LIS的长度， 第三列表示，LIS中到达当前这个数的上一个数的下标，根据这个可以求出LIS序列)

Python 代码如下：

def lis(*args, num=1):
    d = [0] * num
    len_num = 1
    for i in range(num):
        d[i] = 1
        for j in range(i):
            if args[j] <= args[i] and d[i] < d[j] + 1:
                d[i] = d[j] + 1
            if d[i] > len_num:
                len_num = d[i]
        return len_num
print(lis(5, 3, 4, 8, 6, 7))

该算法的时间复杂度是O(n2 )，并不是最优的解法。还有一种很巧妙的算法可以将时间复杂度降到O(nlogn)