算法(01)--动态规划详解


动态规划问题的⼀般形式就是 求最值。动态规划其实是运筹学的⼀种最优化⽅法,只不过在计算机问题上应⽤⽐较多,⽐如说让你求最⻓递增⼦序列 ,最⼩编辑距离呀等等。 既然是要求最值,核⼼问题是什么呢?

求解动态规划的核⼼问题是穷举。因为要求最值,肯定要把所有可⾏的答案穷举出来,然后在其中找最值呗。

⾸先,动态规划的穷举有点特别,因为这类问题存在「重叠⼦问题」,如果 暴⼒穷举的话效率会极其低下,所以需要「备忘录」或者「DP table」来优 化穷举过程,避免不必要的计算。 ⽽且,动态规划问题⼀定会具备「最优⼦结构」,才能通过⼦问题的最值得到原问题的最值。

另外,虽然动态规划的核⼼思想就是穷举求最值,但是问题可以千变万化, 穷举所有可⾏解其实并不是⼀件容易的事,只有列出正确的「状态转移⽅程」才能正确地穷举。

在实际的算法问题中,写出状态转移⽅程是最困难的,这也就是为什么很多朋友觉得动态规划问题困难的原因,我 来提供我研究出来的⼀个思维框架,辅助你思考状态转移⽅程:

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

《斐波那契数列》— 主要是让你明⽩什么是重叠⼦问题

1.1) 暴⼒递归

斐波那契数列的数学形式就是递归的,写成代码就是这样:

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

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

想要计算原问题f(20),我就得先计算出⼦问题f(19)和f(18),然后要计算f(19),我就要先算出⼦问题f(18)和 f(17),以此类推。最后遇到f(1)或者f(2)的时候,结果已知,就能直接返回结果,递归树不再向下⽣⻓了。

递归算法的时间复杂度怎么计算?⼦问题个数乘以解决⼀个⼦问题需要的时间

⼦问题个数,即递归树中节点的总数,显然⼆叉树节点总数为指数级别,所以⼦问题个数为O(2^n)。
解决⼀个⼦问题的时间,在本算法中,没有循环,只有f(n-1)+f(n-2)⼀ 个加法操作,时间为O(1)。 所以,这个算法的时间复杂度为O(2^n),指数级别,爆炸。

观察递归树,很明显发现了算法低效的原因:存在⼤量重复计算,⽐如f(18)被计算了两次,⽽且你可以看到,以f(18)为根的这个递归树体量巨⼤,多算⼀遍,会耗费巨⼤的时间。更何况,还不⽌f(18)这⼀个节点 被重复计算,所以这个算法及其低效。
这就是动态规划问题的第⼀个性质:重叠⼦问题。下⾯我们想办法解决这个问题。

1.2) 带备忘录的递归解法

明确了问题,其实就已经把问题解决了⼀半。即然耗时的原因是重复计算, 那么我们可以造⼀个「备忘录」,每次算出某个⼦问题的答案后别急着返 回,先记到「备忘录」⾥再返回;每次遇到⼀个⼦问题先去「备忘录」⾥查 ⼀查,如果发现之前已经解决过这个问题了,直接把答案拿出来⽤,不要再耗时去计算了。
⼀般使⽤⼀个数组充当这个「备忘录」,当然你也可以使⽤哈希表(字 典),思想都是⼀样的。

    int fib(int N) {
    
        if (N < 1) return 0;
        //	备忘录全初始化为0
        vector<int> memo (N + 1, 0);
        //	初始化最简情况
        return helper(memo, N);
    }

    int helper(vector<int>& memo, int n) {
    
        //	base	case
        if (n == 1 || n == 2) return 1;
        //	已经计算过
        if (memo[n] != 0) return memo[n];
        memo[n] = helper(memo, n - 1) + helper(memo, n - 2);
        return memo[n];
    }

现在,画出递归树,你就知道「备忘录」到底做了什么:
在这里插入图片描述
实际上,带「备忘录」的递归算法,把⼀棵存在巨量冗余的递归树通过「剪 枝」,改造成了⼀幅不存在冗余的递归图,极⼤减少了⼦问题(即递归图中 节点)的个数。
在这里插入图片描述
递归算法的时间复杂度怎么算?----- ⼦问题个数乘以解决⼀个⼦问题需要的时间

⼦问题个数,即图中节点的总数,由于本算法不存在冗余计算,⼦问题就是 f(1) , f(2) , f(3) … f(20) ,数量和输⼊规模 n = 20 成正⽐,所以⼦问题个数为 O(n)。 解决⼀个⼦问题的时间,同上,没有什么循环,时间为 O(1)。 所以,本算法的时间复杂度是 O(n)。⽐起暴⼒算法,是降维打击。
⾄此,带备忘录的递归解法的效率已经和迭代的动态规划解法⼀样了。实际 上,这种解法和迭代的动态规划已经差不多了,只不过这种⽅法叫做「⾃顶向下」,动态规划叫做「⾃底向上」。
啥叫「⾃顶向下」?注意我们刚才画的递归树(或者说图),是从上向下延 伸,都是从⼀个规模较⼤的原问题⽐如说 f(20) ,向下逐渐分解规模,直 到 f(1) 和 f(2) 触底,然后逐层返回答案,这就叫「⾃顶向下」。 啥叫「⾃底向上」?反过来,我们直接从最底下,最简单,问题规模最⼩的 f(1) 和 f(2) 开始往上推,直到推到我们想要的答案 f(20),这就是动态规划的思路,这也是为什么动态规划⼀般都脱离了递归,⽽是由循环迭代完成计算。

1.3) dp 数组的迭代解法

有了上⼀步「备忘录」的启发,我们可以把这个「备忘录」独⽴出来成为⼀ 张表,就叫做 DP table吧,在这张表上完成「⾃底向上」的推算岂不美哉!

    int fib(int N) {
    
        vector<int> dp (N + 1, 0);
        //	base	case
        dp[1] = dp[2] = 1;
        for (int i = 3; i <= N; i++)
            dp[i] = dp[i - 1] + dp[i - 2];
        return dp[N];
    }

在这里插入图片描述
画个图就很好理解了,⽽且你发现这个 DP table 特别像之前那个「剪枝」后 的结果,只是反过来算⽽已。实际上,带备忘录的递归解法中的「备忘录」,最终完成后就是这个DP table,所以说这两种解法其实是差不多的, ⼤部分情况下效率也基本相同。 这⾥引出「状态转移⽅程」这个名词,实际上就是描述问题结构的数学形式:
在这里插入图片描述
为啥叫「状态转移⽅程」?为了听起来⾼端。你把 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,再⽆奥妙可⾔。 这个例⼦的最后,讲⼀个细节优化。细⼼的读者会发现,根据斐波那契数列 的状态转移⽅程,当前状态只和之前的两个状态有关,其实并不需要那么⻓ 的⼀个DP table来存储所有的状态,只要想办法存储之前的两个状态就⾏ 了。所以可以进⼀步优化,把空间复杂度降为O(1):

    int fib(int n) {
    
        if (n == 2 || n == 1) return 1;
        int prev = 1, curr = 1;
        for (int i = 3; i <= n; i++) {
    
            int sum = prev + curr;
            prev = curr;
            curr = sum;
        }
        return curr;
    } 

《凑零钱问题 》— 主要是让你明⽩什么是最优⼦结构

先看下题⽬:给你 k 种⾯值的硬币,⾯值分别为 c1, c2 … ck ,每种硬 币的数量⽆限,再给⼀个总⾦额 amount ,问你最少需要⼏枚硬币凑出这个 ⾦额,如果不可能凑出,算法返回 -1 。算法的函数签名如下:

//	coins中是可选硬币⾯值,amount是⽬标⾦额 
	int	coinChange(int[] coins,	int	amount);

⽐如说 k = 3 ,⾯值分别为 1,2,5,总⾦额 amount = 11。那么最少需 要 3 枚硬币凑出,即 11 = 5 + 5 + 1。 你认为计算机应该如何解决这个问题?显然,就是把所有肯能的凑硬币⽅法 都穷举出来,然后找找看最少需要多少枚硬币。

2.1) 暴⼒递归

⾸先,这个问题是动态规划问题,因为它具有「最优⼦结构」的。要符合 「最优⼦结构」,⼦问题间必须互相独⽴。啥叫相互独⽴?你肯定不想看数学证明,我⽤⼀个直观的例⼦来讲解。
⽐如说,你的原问题是考出最⾼的总成绩,那么你的⼦问题就是要把语⽂考 到最⾼,数学考到最⾼…… 为了每门课考到最⾼,你要把每门课相应的选择题分数拿到最⾼,填空题分数拿到最⾼…… 当然,最终就是你每门课都是满分,这就是最⾼的总成绩。 得到了正确的结果:最⾼的总成绩就是总分。因为这个过程符合最优⼦结 构,“每门科⽬考到最⾼”这些⼦问题是互相独⽴,互不⼲扰的。
但是,如果加⼀个条件:你的语⽂成绩和数学成绩会互相制约,此消彼⻓。 这样的话,显然你能考到的最⾼总成绩就达不到总分了,按刚才那个思路就会得到错误的结果。因为⼦问题并不独⽴,语⽂数学成绩⽆法同时最优,所 以最优⼦结构被破坏。
回到凑零钱问题,为什么说它符合最优⼦结构呢?⽐如你想求 amount = 11 时的最少硬币数(原问题),如果你知道凑出 amount = 10 的最少硬币 数(⼦问题),你只需要把⼦问题的答案加⼀(再选⼀枚⾯值为1 的硬币) 就是原问题的答案,因为硬币的数量是没有限制的,⼦问题之间没有相互制约,是互相独⽴的。 那么,既然知道了这是个动态规划问题,就要思考如何列出正确的状态转移⽅程?

  • 先确定「状态」,也就是原问题和⼦问题中变化的变量。由于硬币数量⽆ 限,所以唯⼀的状态就是⽬标⾦额 amount;
  • 然后确定 dp 函数的定义:当前的⽬标⾦额是 n,⾄少需要dp(n)个硬 币凑出该⾦额;
  • 然后确定「选择」并择优,也就是对于每个状态,可以做出什么选择改变当前状态。具体到这个问题,⽆论当的⽬标⾦额是多少,选择就是从⾯额列表coins中选择⼀个硬币,然后⽬标⾦额就会减少:
    //	伪码框架
    def coinChange(coins:List[int], amount:int):
        //	定义:要凑出⾦额 n,⾄少要dp(n)个硬币
        def dp(n):
        //	做选择,选择需要硬币最少的那个结果
        for coin in coins:
        res=min(res,1+dp(n-coin))
        return res
        //	我们要求的问题是 dp(amount)
        return dp(amount)
  • 最后明确 basecase,显然⽬标⾦额为 0 时,所需硬币数量为0;当⽬标⾦额⼩于 0 时,⽆解,返回-1:
    def coinChange(coins:List[int], amount:int):
        def dp(n):
        // base case 
        if n==0:return 0
        if n< 0:return-1
        // 求最⼩值,所以初始化为正⽆穷								
        res=float('INF')
        for coin in coins:
        subproblem=dp(n-coin)
        // ⼦问题⽆解,跳过												
        if subproblem==-1:continue
        res=min(res,1+subproblem)
        return res if res!=float('INF')else-1
        return dp(amount)

⾄此,状态转移⽅程其实已经完成了,以上算法已经是暴⼒解法了,以上代码的数学形式就是状态转移⽅程:
在这里插入图片描述
⾄此,这个问题其实就解决了,只不过需要消除⼀下重叠⼦问题,⽐如amount = 11, coins = {1,2,5} 时画出递归树看看:
在这里插入图片描述
时间复杂度分析:⼦问题总数 x 每个⼦问题的时间
⼦问题总数为递归树节点个数,这个⽐较难看出来,是 O(n^k),总之是指数级别的。每个⼦问题中含有⼀个 for 循环,复杂度为 O(k)。所以总时间复 杂度为O(k * n^k),指数级别。

2.2) 带备忘录的递归

只需要稍加修改,就可以通过备忘录消除⼦问题:

        def coinChange(coins:List[int],amount:int):
        //	备忘录
        memo=dict()
        def dp(n):
            //	查备忘录,避免重复计算
            if n in memo:return memo[n]
            if n==0:return 0
            if n<	0:return-1
            res=float('INF')
            for coin in coins:
                subproblem=dp(n-coin)
                if subproblem==-1:continue
                res=min(res,1+subproblem)

            //	记⼊备忘录
            memo[n]=res if res!=float('INF') else-1
            return memo[n]
        return dp(amount)

很显然「备忘录」⼤⼤减⼩了⼦问题数⽬,完全消除了⼦问题的冗余,所以⼦问题总数不会超过⾦额数n,即⼦问题数⽬为 O(n)。处理⼀个⼦问题的时间不变,仍是O(k),所以总的时间复杂度是O(kn)。

2.3) dp 数组的迭代解法

当然,我们也可以⾃底向上使⽤ dp table 来消除重叠⼦问题, dp数组的定义和刚才dp函数类似,定义也是⼀样的: dp[i] = x 表⽰,当⽬标⾦额为i时,⾄少需要 x 枚硬币

        int	coinChange(vector<int>&	coins,	int	amount)	{
    
                    //	数组⼤⼩为	amount	+	1,初始值也为	amount	+	1
       	    vector<int>	dp(amount	+	1,	amount	+	1);
       	    //	base	case
        	dp[0]=0;
        	for	(int i = 0;	i < dp.size();	i++){
    
        	    //	内层	for	在求所有⼦问题	+	1	的最⼩值
                for	(int coin :	coins)	{
    
                    //	⼦问题⽆解,跳过
                	if	(i - coin <	0)	continue;
                	dp[i] =	min(dp[i],	1 +	dp[i - coin]);
                 }
        	}
        	return	(dp[amount]	==	amount	+	1)	?	-1	:	dp[amount];
    }

在这里插入图片描述
PS:为啥 dp数组初始化为 amount+ 1 呢?
因为凑成 amount⾦额的硬币数最多只可能等于amount(全⽤1元⾯值的硬币),所以初始化为amount+1就相当于初始化为正⽆穷,便于后续取最⼩值。

总结

第⼀个斐波那契数列的问题,解释了如何通过「备忘录」或者「dp table」 的⽅法来优化递归树,并且明确了这两种⽅法本质上是⼀样的,只是⾃顶向 下和⾃底向上的不同⽽已。
第⼆个凑零钱的问题,展⽰了如何流程化确定「状态转移⽅程」,只要通过状态转移⽅程写出暴⼒递归解,剩下的也就是优化递归树,消除重叠⼦问题⽽已。
计算机解决问题其实没有任何奇技淫巧,它唯⼀的解决办法就是穷举,穷举所有可能性。算法设计⽆⾮就是先思考“如何穷举”,然后再追求“如何聪明 地穷举”。 列出动态转移⽅程,就是在解决“如何穷举”的问题。之所以说它难,⼀是因为很多穷举需要递归实现,⼆是因为有的问题本⾝的解空间复杂,不那么容易穷举完整。 备忘录、DP table 就是在追求“如何聪明地穷举”。⽤空间换时间的思路,是降低时间复杂度的不⼆法门。


本文内容来源----公众号:labuladong 《labuladong的算法小抄》 提取码:g9l2

猜你喜欢

转载自blog.csdn.net/jianghao233/article/details/109067819