方式一:1、暴力递归
斐波那契数列的数学形式就是递归的,写成代码就是这样:
int fib(int N) {
if (N == 1 || N == 2) return 1;
return fib(N - 1) + fib(N - 2);
}
- 这个不用多说了,学校老师讲递归的时候似乎都是拿这个举例。我们也知道这样写代码虽然简洁易懂,但是十分低效,低效在哪里?假设 n = 20,请画出递归树:
-
但凡遇到需要递归的问题,最好都画出递归树,这对你分析算法的复杂度,寻找算法低效的原因都有巨大帮助。
-
这个递归树怎么理解?就是说想要计算原问题
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) 这一个节点被重复计算,所以这个算法及其低效。
这就是动态规划问题的第一个性质:重叠子问题。下面,我们想办法解决这个问题。
方式二:带备忘录的递归解法
-
明确了问题,其实就已经把问题解决了一半。即然耗时的原因是重复计算,那么我们可以造一个「
备忘录」
,每次算出某个子问题的答案后别急着返回,先记到「备忘录」里再返回;每次遇到一个子问题先去「备忘录」里查一查,如果发现之前已经解决过这个问题了,直接把答案拿出来用,不要再耗时去计算了。 -
一般使用一个数组充当这个「备忘录」,当然你也可以使用
哈希表(字典)
,思想都是一样的。
我们想算
f(20)
就得先算f(19)
和f(18)
,算f(19)过程中要算f(17)和f(18),这样一直推下去,直到f(1)和f(2),然后再反推回去。这个过程就是先自定向下的递归,然后是自底向上的回溯答案。
//自定向下的
class Solution {
public int fib(int n) {
/*
带递归的备忘录解法
*/
//备忘录全初始化为0
int[] memo = new int[n+1];//这里n+1是数组的长度,因为从0~n哦
//进行带备忘录的递归
return helper(memo,n);
}
private int helper(int[] memo,int n){
if(n == 0 || n == 1) return n;
//已经计算过了,不用再算了,直接返回这个数
if(memo[n] != 0) return memo[n];//也叫剪枝的优化
/*把计算结果存到memo数组(备忘录)中,目的就是在准备调用递归函数helper之前
先到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)
这两个base case
,然后逐层返回答案,这就叫「自顶向下」
。 -
啥叫
「自底向上」
?反过来,我们直接从最底下,最简单,问题规模最小的f(1)
和f(2)
开始往上推,直到推到我们想要的答案f(20)
,这就是动态规划的思路,这也是为什么动态规划一般都脱离了递归,而是由循环迭代完成计算。
方式三:dp 数组的迭代解法
有了上一步「备忘录」的启发,我们可以把这个「备忘录」独立出来成为一张表,就叫做 DP table 吧,在这张表上完成「自底向上」的推算岂不美哉!
/*自底向上的数组的迭代算法,迭代算法有一个好处就是:
我们可能再进一步的优化空间复杂度*/
class Solution {
public int fib(int n) {
if(n == 0) return n;
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];
}
}
画个图就很好理解了,而且你发现这个 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)
:
class Solution {
//优化空间复杂度
public int fib(int n) {
if (n == 0 || n == 1) return 1;
//递推关系
int prev = 0, curr = 1;
for (int i = 2; i <= n; i++) {
int sum = prev + curr;
prev = curr;
curr = sum;
}
return curr;
}
}
这个技巧就是所谓的「状态压缩」
,如果我们发现每次状态转移只需要 DP table 中的一部分,那么可以尝试用状态压缩来缩小 DP table 的大小,只记录必要的数据,上述例子就相当于把DP table 的大小从 n
缩小到 2
。后续的动态规划章节中我们还会看到这样的例子,一般来说是把一个二维的 DP table 压缩成一维,即把空间复杂度从 O(n^2)
压缩到 O(n)
。
有人会问,动态规划的另一个重要特性「最优子结构」,怎么没有涉及?下面会涉及。斐波那契数列的例子严格来说不算动态规划,因为没有涉及求最值,以上旨在说明重叠子问题的消除方法,演示得到最优解法逐步求精的过程。