动态规划的学习_动态规划学习

动态规划的学习

一、什么是动态规划？

动态规划问题的一般形式就是求最值。

比如求最长递增子序列、最小编辑距离等

求最值的核心问题是什么？

就是把所有可行的答案穷举出来，然后在其中找最值

求解动态规划的核心问题就是穷举。

但是问题千变万化，穷举所有可行解并不是一个容易的事，只有列出正确的状态转移方程才能正确地穷举。

而且我们需要判断算法问题是否具备最优子结构，即是否能够通过子问题的最值得到原问题的最值

另外，动态规划问题存在重叠子问题，如果暴力穷举的话效率会很低，所以我们需要使用备忘录或者DP table来优化穷举过程，避免不必要的计算

这就是动态规划三要素：重叠子问题、最优子结构、状态转移方程

状态转移方程是最困难的

二、如何思考状态转移方程？

明确 base case -> 明确「状态」-> 明确「选择」 -> 定义 dp 数组/函数的含义。

# 自顶向下递归的动态规划
def dp(状态1, 状态2, ...):
    for 选择 in 所有可能的选择:
        # 此时的状态已经因为做了选择而改变
        result = 求最值(result, dp(状态1, 状态2, ...))
    return result

# 自底向上迭代的动态规划
# 初始化 base case
dp[0][0][...] = base case
# 进行状态转移
for 状态1 in 状态1的所有取值：
    for 状态2 in 状态2的所有取值：
        for ...
            dp[状态1][状态2][...] = 求最值(选择1，选择2...)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

三、动态规划的基本原理

在这里用两个典型问题来学习动态规划的基本原理

• 斐波那契数列问题——明白什么是重叠子问题（斐波那契数列没有求最值，所以严格来说不是动态规划问题）
• 凑零钱问题——学习如何列出状态转移方程

1.509. 斐波那契数

1.1 暴力递归解法：

斐波那契数列的数学形式就是递归的

int fib(int N) {
    if (N == 1 || N == 2) return 1;
    return fib(N - 1) + fib(N - 2);
}
1
2
3
4

这段代码非常的简洁易懂但是非常低效，为什么？

假设n=20，递归树如图所示：

如何解读这个递归树？

• 想要计算原问题f(20)，我们就得先计算出子问题19和18

• 然后要计算19，我们就得先计算出18和17

• 以此类推，最后遇到1和2的时候，结果已知就能直接返回结果，递归树不再向下生长

1.1.1 递归算法的时间复杂度

ps：但凡遇到需要递归的问题，最好都画出递归树，这对你分析算法的复杂度，寻找算法低效的原因都有巨大帮助。

递归算法的时间复杂度就是用子问题个数乘以解决一个子问题需要的时间

1. 首先计算子问题个数，即递归树中节点的总数。（显然二叉树节点总数为指数级别，所以子问题个数为 O(2^n)）
2. 然后计算解决一个子问题的时间，在本递归算法中没有循环，只有 f(n - 1) + f(n - 2) 一个加法操作，时间为 O(1)。
3. 所以这个算法的时间复杂度为二者相乘，即 O(2^n)，指数级别，爆炸。

那为什么时间复杂度会这么大呢？

观察递归树就能发现算法低效的原因：存在大量重复计算

例如f(18)被计算了两次，而且以f(18)为根的这个递归树体量巨大，多算一遍就会耗费巨大的时间。

更何况不止f(18)这一个节点被重复计算，所以这个算法非常低效

1.1.2 在leetCode上通过的代码

//在leetCode上通过的代码
class Solution {
    public int fib(int n) {
        //递归解法 
        //base case
        if(n==0) return 0;
        if(n==1||n==2) return 1;
        return fib(n-1)+fib(n-2);   
    }
}
1
2
3
4
5
6
7
8
9
10

1.2 带备忘录的递归解法：

前面我们说了，递归算法存在重复计算所以导致算法低效。

那么针对这个问题，我们的解决方法就是造一个备忘录

每次算出某个子问题的答案不急着返回，先记到备忘录里再返回。

每次遇到一个子问题先去备忘录里查一查，如果发现之前已经解决过这个问题，直接把答案拿出来用，不需要在花费时间去计算

我们一般使用一个数组充当备忘录，当然我们也可以使用哈希表（字典），思想都是一样的

int fib(int N) {
    // 备忘录全初始化为 0
    int[] memo = new int[N + 1];
    // 进行带备忘录的递归
    return dp(memo, N);
}

// 带着备忘录进行递归
int dp(int[] memo, int n) {
    // base case
    if (n == 0 || n == 1) return n;
    // 已经计算过，不用再计算了
    if (memo[n] != 0) return memo[n];
    memo[n] = dp(memo, n - 1) + dp(memo, n - 2);
    return memo[n];
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

带备忘录的递归解法的递归树如下：

如图，我们就知道备忘录的作用是什么了。

实际上，带备忘录的递归算法就是把一棵存在巨量冗余的递归树通过剪枝改造成一幅不存在冗余的递归树，极大减少了子问题（即递归树中节点）的个数

1.2.1 在leetCode上通过的代码

//在leetCode上通过的代码
class Solution {
    int[] memo;
    public int fib(int n) {
        //带备忘录的递归算法,注意要是n+1，否则边界溢出
        memo=new int[n+1];
        return dp(memo,n);
    }
    public int dp(int[] memo,int n){
        //base case
        if(n==0) return 0;
        if(n==1||n==2) return 1;
        if(memo[n]!=0){
            return memo[n];
        }
        //如果备忘录没有存在这个数，那么计算然后存到备忘录中
        memo[n]=dp(memo,n-1)+dp(memo,n-2);
        return memo[n];
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

1.2.2 带备忘录的递归算法的时间复杂度

带备忘录的递归算法的时间复杂度就是用子问题个数乘以解决一个子问题需要的时间

子问题个数就是图中节点的总数

由于本算法中不存在冗余计算，子问题就是f(1)、f(2)…f(20),数量和输入规模n=20成正比，所以子问题个数为 O(n)

解决一个子问题的时间同上，没有什么循环所以时间为O(1)

所以，本算法的时间复杂度是 O(n)，比起暴力算法，是降维打击

实际上这种解法和常见的动态规划解法已经差不多，只不过这种解法是自顶向下进行递归求解，而我们常见的动态规划代码是自顶向上进行递推求解

什么是自顶向上？

以刚刚我们那两棵递归树为例，是从上向延伸的

都是从一个规模较大的原问题，比如f(20)，向下逐渐分解规模，直到f(1)和f(2)这两个base case，然后逐层返回答案，这就叫自顶向下

什么是自底向上？

反过来，我们是直接从最底下、最简单、问题规模最小、已知结果的f(1)和f(2)(base case)开始向上推，直到推到我们想要的答案f(20)。这就是递推的思路，这也是动态规划一般都脱离了递归，而是由循环迭代完成计算的原因

1.3 dp 数组的迭代（递推）解法

有了上一步备忘录的启发，我们可以把这个备忘录独立出来成为一张表，通常叫做DP table，在这张表上完成自底向上的推算

int fib(int N) {
    if (N == 0) return 0;
    int[] dp = new int[N + 1];
    // base case
    dp[0] = 0; dp[1] = 1;
    // 状态转移
    for (int i = 2; i <= N; i++) {
        dp[i] = dp[i - 1] + dp[i - 2];
    }

    return dp[N];
}
1
2
3
4
5
6
7
8
9
10
11
12

1.3.1 在leetCode上通过的代码

//在leetCode上通过的代码
class Solution {
    public int fib(int n) {
        //用dp table完成自底向上的解法
        if(n==0) return 0;
        int[] dp=new int[n+1];
        //base case
        dp[0]=0;
        dp[1]=1;
        //状态转移
        for(int i=2;i<=n;i++){
            dp[i]=dp[i-1]+dp[i-2];
        }
        return dp[n];
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

这个DP table特别像之前那个剪枝后的结果，只是反过来算了。

实际上，带备忘录的递归解法中的备忘录，最终完成后就是这个DP table。

所以这两个解法其实是差不多的，大部分情况下，效率基本相同

借此引出状态转移方程

这个名词实际上就是描述问题结构的数学形式：

1.4 什么是状态转移方程？

状态转移方程只是听起来高级

f(n) 的函数参数会不断变化，所以你把参数 n 想做一个状态，这个状态 n 是由状态 n - 1 和状态 n - 2 转移（相加）而来，这就叫状态转移，仅此而已。

然后我们可以发现在以上几种解法中的所有操作，例如 return f(n - 1) + f(n - 2)，dp[i] = dp[i - 1] + dp[i - 2]以及对备忘录或DP table的初始化操作都是围绕这个方程式的不同表现形式。

可见列出状态转移方程的重要性，他就是解决问题的核心

状态转移方程往往直接代表着暴力解法

暴力解是非常重要的！动态规划问题最困难的就是写出这个暴力解，即状态转移方程

只要写出暴力解，优化方法无非是用备忘录或者DP table

1.5 细节优化

根据斐波那契数列的状态转移方程，当前状态n只和之前的n-1和n-2两个状态有关，其实并不需要那么长的一个DP table来存储所有状态，只要想办法存储之前的两个状态就行了

所以可以进一步优化，把空间复杂度降为O(1)。

1.5.1 这就是我们最常见的计算斐波那契数列的算法

int fib(int n) {
    if (n == 0 || n == 1) {
        // base case
        return n;
    }
    // 分别代表 dp[i - 1] 和 dp[i - 2]
    int dp_i_1 = 1, dp_i_2 = 0;
    for (int i = 2; i <= n; i++) {
        // dp[i] = dp[i - 1] + dp[i - 2];
        int dp_i = dp_i_1 + dp_i_2;
        // 滚动更新
        dp_i_2 = dp_i_1;
        dp_i_1 = dp_i;
    }
    return dp_i_1;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

这就相当于把DP table 的大小从 n 缩小到 2

这一般是动态规划问题的最后一步优化，如果我们发现每次状态转移只需要DP table中的一部分，那么可以尝试缩小DP table的大小，只记录必要的数据，从而降低空间复杂度

1.5.2 在leetCode上通过的代码

//在leetCode上通过的代码
class Solution {
    public int fib(int n) {
        //dp table完成的自底向上的算法的细节优化
        //因为只与上两个状态有关所以就保存这两个状态就好了
        if(n==0) return 0;
        int dp_i_1=1;
        int dp_i_2=0;
        for(int i=2;i<=n;i++){
            int dp_i=dp_i_1+dp_i_2;
            //滚动更新
            dp_i_2=dp_i_1;
            dp_i_1=dp_i;
        }     
        return dp_i_1;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

1.6 总结

斐波那契数列的例子严格来说不算动态规划，因为没有涉及求最值，以上旨在说明重叠子问题的消除方法，演示得到最优解法逐步求精的过程

2.322. 零钱兑换

解决这个问题最简单的方法就是把所有可能的凑硬币的方法都穷举出来然后找找最少需要多少枚硬币

2.1 什么是最优子结构？

要符合最优子结构，子问题间必须互相独立。

什么叫相互独立？

好比我们考试，每门科目的成绩都是相互独立的

我们的原问题是考出最高的总成绩

那么子问题就是把科目一考到最高、科目二考到最高…

为了每门课考到最高，我们就要把每门课相应的题目分数拿到最高：选择题分数拿到最高、填空题分数拿到最高…

如果最终我们每门课的成绩都是满分，那么这就是最高的总成绩

这就得到了正确的结果：最高的总成绩就是总分，每门科目考到最高这些子问题相互独立、互不干扰

这就符合最优子结构

但是加入我们让科目一和科目二的成绩相互制约，不能同时达到满分，即科目一分数高、科目二分数就会降低，反之亦然。

有了这个制约条件我们的最高总成绩就达不到总分了。

假如我们还是按照刚才的思路就会得到错误的结果。因为每门科目考到最高的子问题并不独立，科目一和科目二成绩互相影响，无法同时最优，所以最优子结构被破坏

2.2 暴力递归解法：

凑零钱这个问题是动态规划问题，因为它具有最优子结构

但是为什么说它符合最优子结构呢？

假设我们有面值为1，2，5的硬币，

我们想求amount=11时的最少硬币数（原问题）

如果我们知道凑出amount=10，9，6的最少硬币数（子问题）

我们只需要把子问题的答案加一（再选一枚面值为1，2，5的硬币），求个最小值就是原问题的答案。

因为硬币的数量是没有限制的，所以子问题之间没有相互制约，是互相独立的

2.2.1 如何列出正确的状态转移方程？

既然这是个动态规划问题，那我们如何列出正确的状态转移方程？

1. 确定base case

   这个很简单，显然目标金额amount为0时算法返回0，因为不需要任何硬币就已经可以凑出目标金额了

2. 确定状态，也就是原问题和子问题中会变化的变量

   由于硬币数量不限制，硬币的面额也是题目给定的，只有目标金额会不断地向base case靠近，所以唯一的状态就是目标金额amount

3. 确定选择，也就是导致状态产生变化的行为

   目标金额为什么变化呢？因为我们在选择硬币，我们每选择一枚硬币就相当于减少了目标金额。

   所以说所有硬币的面值就是我们的选择

4. 明确dp函数/数组的定义

   我们这里讲的是自顶向下的解法，所以会有一个递归的dp函数。

   一般来说函数的参数就是状态转移中会变化的量，也就是上面说到的状态；函数的返回值就是题目要求我们计算的量。

   就本题来说，状态只有一个，即目标金额，题目要求我们计算凑出目标金额所需的最少硬币数量

根据以上4点，解法的伪代码如下：

// 伪码框架
int coinChange(int[] coins, int amount) {
    // 题目要求的最终结果是 dp(amount)
    return dp(coins, amount)
}

// 定义：要凑出金额 n，至少要 dp(coins, n) 个硬币
int dp(int[] coins, int n) {
    // 做选择，选择需要硬币最少的那个结果
    for (int coin : coins) {
        res = min(res, 1 + dp(coins, n - coin))
    }
    return res
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

根据以上伪代码，我们加上base case即可的到最终答案

base case：目标金额为0时，所需硬币数量为0；当目标金额小于0时，无解，返回-1.

int coinChange(int[] coins, int amount) {
    // 题目要求的最终结果是 dp(amount)
    return dp(coins, amount)
}

// 定义：要凑出金额 n，至少要 dp(coins, n) 个硬币
int dp(int[] coins, int amount) {
    // base case
    if (amount == 0) return 0;
    if (amount < 0) return -1;

    int res = Integer.MAX_VALUE;
    for (int coin : coins) {
        // 计算子问题的结果
        int subProblem = dp(coins, amount - coin);
        // 子问题无解则跳过
        if (subProblem == -1) continue;
        // 在子问题中选择最优解，然后加一
        res = Math.min(res, subProblem + 1);
        //这里的res取最小值可以理解为在一轮面值的选择中选取最优解，也就是说假如这一轮选择1、2、5分别对应的结果取最小值
        //而这里的子问题加1就是表示硬币数加1
    }

    return res == Integer.MAX_VALUE ? -1 : res;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

到这里，状态转移方程就已经完成了，以上算法已经是暴力解法，所以以上代码的数学形式就是状态转移方程

这个解法对应的递归树如下

以amount = 11, coins = {1,2,5}为例

2.2.2 递归算法的时间复杂度：

递归算法的时间复杂度=子问题总数*解决每个子问题所需的时间

• 子问题总数就是递归树的节点个数

  但是算法会进行剪枝，剪枝的时机和题目给定的具体硬币面额有关

  所以可以想象，这棵树生长的并不规则，确切算出树上有多少节点是比较困难的。

  对于这种情况我们一般的做法是按照最坏的情况算一个时间复杂度的上界。

  假设目标金额为n，给定的硬币个数为k，那么递归树最坏情况下高度为n（全用面额为1的硬币），然后再假设这是一棵满k叉树，则节点的总数在 k^n 这个数量级。

• 由于每次递归包含一个for循环，复杂度为O(k)，相乘的到总时间复杂度为 O(k^n)，指数级别

2.2.3 在leetCode上通过的代码

//在leetCode上的代码
class Solution {
    public int coinChange(int[] coins, int amount) {
        //递归算法
        return dp(coins,amount);
    }
    public int dp(int[] coins,int n){
        //base case
        if(n==0) return 0;
        if(n<0) return -1;
        int res=Integer.MAX_VALUE;
        //遍历每一种面额，确定最少数目
        for(int coin:coins){
            int subProblem=dp(coins,n-coin);
            if(subProblem==-1) continue;
            //在有解的子问题中寻找最优解
            res=Math.min(res,subProblem+1);
        }
        return res==Integer.MAX_VALUE?-1:res;
    }
} 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

但是因为时间复杂度太高了，所以会超出时间限制

2.3 带备忘录的递归解法

类似之前的斐波那契数列的例子，只需要稍加修改就可以通过备忘录消除子问题

class Solution {
    int[] memo;

    int coinChange(int[] coins, int amount) {
        memo = new int[amount + 1];
        // 备忘录初始化为一个不会被取到的特殊值，代表还未被计算
        Arrays.fill(memo, -666);

        return dp(coins, amount);
    }

    int dp(int[] coins, int amount) {
        if (amount == 0) return 0;
        if (amount < 0) return -1;
        // 查备忘录，防止重复计算
        if (memo[amount] != -666)
            return memo[amount];

        int res = Integer.MAX_VALUE;
        for (int coin : coins) {
            // 计算子问题的结果
            int subProblem = dp(coins, amount - coin);
            // 子问题无解则跳过
            if (subProblem == -1) continue;
            // 在子问题中选择最优解，然后加一
            res = Math.min(res, subProblem + 1);
        }
        // 把计算结果存入备忘录
        memo[amount] = (res == Integer.MAX_VALUE) ? -1 : res;
        return memo[amount];
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

2.3.1 在leetCode上通过的代码

class Solution {
    int[] memo;
    public int coinChange(int[] coins, int amount) {
        //带备忘录的递归算法
        memo=new int[amount+1];
        Arrays.fill(memo, -666);
        return dp(coins,amount);
    }
    public int dp(int[] coins,int n){
        //base case
        if(n==0) return 0;
        if(n<0) return -1;
        //查备忘录，看看有没有已经算过了，已经算过直接返回结果
        if(memo[n]!=-666){
            return memo[n];
        }
        int res=Integer.MAX_VALUE;
        //遍历每一种面额，确定最少数目
        for(int coin:coins){
            int subProblem=dp(coins,n-coin);
            if(subProblem==-1) continue;
            //在有解的子问题中寻找最优解
            res=Math.min(res,subProblem+1);
            //存到备忘录中
        }
        //如果放在循环里面的话就会出现所有的子问题都等于-1而跳出循环，然后memo[n]就没有被重新赋值，就会给出不符合题目要求的数
        memo[n]=(res==Integer.MAX_VALUE)?-1:res;
        return memo[n];
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

备忘录大大减少了子问题数目，完全消除了子问题的冗余，所以子问题总数不会超过金额数n

2.3.2 带备忘录的递归算法的时间复杂度：

子问题总数不会超过金额数n

即子问题数目为O(n)

处理一个子问题的时间不变，仍是O(k)

所以总的时间复杂度为O(kn)

2.4 dp 数组的迭代解法

在这里我们也可以自底向上使用dp table来消除重叠子问题

关于状态、选择和base case与之前没有区别

dp数组的定义和刚才的dp函数类似，也是把状态（也就是目标金额作为变量）。

不过dp函数体现在函数参数，而dp数组体现在数组索引：

dp 数组的定义：当目标金额为 i 时，至少需要 dp[i] 枚硬币凑出。

int coinChange(int[] coins, int amount) {
    int[] dp = new int[amount + 1];
    // 数组大小为 amount + 1，初始值也为 amount + 1
    Arrays.fill(dp, amount + 1);

    // base case
    dp[0] = 0;
    // 外层 for 循环在遍历所有状态的所有取值
    for (int i = 0; i < dp.length; i++) {
        // 内层 for 循环在求所有选择的最小值
        for (int coin : coins) {
            // 子问题无解，跳过
            if (i - coin < 0) {
                continue;
            }
            dp[i] = Math.min(dp[i], 1 + dp[i - coin]);
        }
    }
    return (dp[amount] == amount + 1) ? -1 : dp[amount];
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

为什么 dp 数组中的值都初始化为 amount + 1 呢？

因为凑成 amount 金额的硬币数最多只可能等于 amount（全用 1 元面值的硬币），所以初始化为 amount + 1 就相当于初始化为正无穷，便于后续取最小值。

为什么不直接初始化为 int 型的最大值 Integer.MAX_VALUE 呢？因为后面有 dp[i - coin] + 1，这就会导致整型溢出。

2.4.1 在leetCode上通过的代码

class Solution {
    public int coinChange(int[] coins, int amount) {
        //使用dp数组的自底向上的解法
        int[] dp=new int[amount+1];
        Arrays.fill(dp,amount+1);
        //base case
        dp[0]=0;
        //外层for循环在遍历所有状态的所有取值
        for(int i=0;i<dp.length;i++){
            //内层循环在求所有选择的最小值
            for(int coin:coins){
                //子问题无解，跳过
                if(i-coin<0){
                    continue;
                }
                //有多少种面额一层循环就有多少个dp[n]
                dp[i]=Math.min(dp[i],1+dp[i-coin]);
            }
        }
        return (dp[amount]==amount+1)?-1:dp[amount];
        
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

四、总结

1. 斐波那契数列的问题解释了如何通过备忘录或者dp table的方法来优化递归树并且明确两种方法本质上是一样的，只是自顶向上和自底向下的区别而已
2. 凑零钱问题展示了如何流程化确定状态转移方程，只要通过状态转移方程写出暴力递归解，剩下的也就是优化递归树，消除重叠子问题而已

计算机解决问题——穷举

计算机解决问题其实没有任何特殊的技巧，它唯一的解决办法就是穷举（穷举所有的可能性 ）

算法设计无非就是先思考如何穷举，然后再追求如何聪明地穷举

• 列出状态转移方程就是在解决如何穷举的问题。

  之所以说难，一是因为很多琼剧都需要递归实现；二是因为有的问题本身的解空间复杂，不那么容易穷举完整

• 备忘录、DP table就是在追求如何聪明地穷举。用空间换时间的思路，是降低时间复杂度的不二法门