1.2.1-斐波那契数列4种解法(暴力递归+动态规划)
Reference
LeetCode 509. 斐波那契数列
labuladong的算法小抄
Markdown语法
Labuladong的算法小抄(纸质书籍 2021年1月第1版,2022年1月第七次印刷 第2章,第1节)
此问题解法和下一个凑零钱问题解法,我都会详细介绍解法原理,再后续动态规划算法原理和此相同,我只会解释题目解决方案窍门(即找到“状态”、“选择”和状态转移方程),不会再详细解释其他相关知识。
动态规划一般解法
暴力穷举 -> 带备忘录的递归解法 -> dp 数组的迭代解法。
找到“状态”和“选择”->明确dp数组/函数的定义->寻找状态之间的关系。
难点
- dp数组的含义
- 寻找正确的状态转移方程(数学归纳法)
代码解释详见 Labuladong的算法小抄 书箱(2022年1月第七次印刷) pp.31-37
方法1:暴力递归 (存在大量的重叠子问题)
递归问题最好都画出递归树,方法理解算法和计算时间空间复杂度
递归算法的时间复杂度:用子问题个数乘以解决一个子问题需要的时间。
def func(N):
# arr = list(map(int,input().strip().split()))
# N = int(input())
def fib(N):
if N == 0:
return 0
if N == 1 or N == 2:
return 1
else:
return fib(N-1) + fib(N-2)
return fib(N)
if __name__ == '__main__':
N = int(input())
c = func(N)
print(c)
for i in range(N+1):
print(func(i), end=" ")
⼦问题个数,即递归树中节点的总数。显然⼆叉树节点总数为指数级别,所以⼦问题个数为 O(2^n)。
解决⼀个⼦问题的时间,在本算法中,没有循环,只有 f(n - 1) + f(n - 2) ⼀个加法操作,时间为 O(1)。所以,这个算法的时间复杂度为 O(2^n),指数级别,爆炸。
观察递归树,很明显发现了算法低效的原因:存在⼤量重复计算,⽐如 f(18) 被计算了两次,⽽且你可以看到,以 f(18) 为根的这个递归树体量巨⼤,多算⼀遍,会耗费巨⼤的时间。更何况,还不⽌ f(18) 这⼀个节点被重复计算,所以这个算法及其低效。
这就是动态规划问题的第⼀个性质:重叠⼦问题。下⾯,我们想办法解决这个问题
方法2:带备忘录的递归解法 (使用memo数组或者哈希表充当备忘录)
观察方法1的递归树,此方法相当于存在巨量冗余的递归二叉树,备忘录相当于提供了一套“剪枝”操作。使递归树改造成了一幅不存在冗余的递归树。极大地减少了子问题
实际上,带「备忘录」的递归算法,把⼀棵存在巨量冗余的递归树通过「剪枝」,改造成了⼀幅不存在冗余的递归图,极⼤减少了⼦问题(即递归图中节点)的个数。
def func(N):
# arr = list(map(int,input().strip().split()))
# N = int(input())
def fib(N):
if N == 0:
return 0
memo = [0] * (N+1)
return helper(memo,N)
def helper(memo,N):
if N == 1 or N == 2:
memo[N] = 1
return memo[N]
if memo[N] != 0:
return memo[N]
memo[N] = helper(memo,N-1) + helper(memo,N-2)
return memo[N]
return fib(N)
if __name__ == '__main__':
N = int(input())
c = func(N)
print(c)
for i in range(N+1):
print(func(i), end=" ")
⼦问题个数,即图中节点的总数,由于本算法不存在冗余计算,⼦问题就是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),这就是动态规划的思路,这也是为什么动态规划⼀般都脱离了递归,⽽是由循环迭代完成计算
方法3:dp数组的迭代解法 (DP table 自底向上解法)
有了上⼀步「备忘录」的启发,我们可以把这个「备忘录」独⽴出来成为⼀张表,就叫做 DP table 吧,在这张表上完成「⾃底向上」的推算岂不美哉!
def func(N):
# arr = list(map(int,input().strip().split()))
# N = int(input())
def fib(N):
if N == 0:
return 0
if N == 1 or N == 2:
return 1
dp = [0] * (N + 1) # 加1是把N=0时返回0考虑进去了。 #float('inf')
dp[1],dp[2] = 1,1
for i in range(3,N+1):
dp[i] = dp[i-1] + dp[i-2]
return dp[N]
return fib(N)
if __name__ == '__main__':
N = int(input())
c = func(N)
print(c)
for i in range(N+1):
print(func(i), end=" ")
画个图就很好理解了,⽽且你发现这个DPtable特别像之前那个「剪枝」后的结果,只是反过来算⽽已。实际上,带备忘录的递归解法中的「备忘录」,最终完成后就是这个DPtable,所以说这两种解法其实是差不多的,⼤部分情况下,效率也基本相同。
这⾥,引出「状态转移⽅程」这个名词,实际上就是描述问题结构的数学形式:
为啥叫「状态转移⽅程」?为了听起来⾼端。你把f(n)想做⼀个状态n,这个状态n是由状态n-1和状态n-2相加转移⽽来,这就叫状态转移,仅此⽽已。
你会发现,上⾯的⼏种解法中的所有操作,例如returnf(n-1)+f(n-2),dp[i]=dp[i-1]+dp[i-2],以及对备忘录或DPtable的初始化操作,都是围绕这个⽅程式的不同表现形式。可⻅列出「状态转移⽅程」的重要性,它是解决问题的核⼼。很容易发现,其实状态转移⽅程直接代表着暴⼒解法。
千万不要看不起暴⼒解,动态规划问题最困难的就是写出状态转移⽅程,即这个暴⼒解。优化⽅法⽆⾮是⽤备忘录或者 DP table,再⽆奥妙可⾔!
方法4:dp数组的迭代解法+状态压缩
这个例⼦的最后,讲⼀个细节优化。细⼼的读者会发现,根据斐波那契数列的状态转移⽅程,当前状态只和之前的两个状态有关,其实并不需要那么⻓的⼀个DPtable来存储所有的状态,只要想办法存储之前的两个状态就⾏了。所以,可以进⼀步优化,把空间复杂度降为O(1):
def func(N):
# arr = list(map(int,input().strip().split()))
# N = int(input())
def fib(N):
if N == 0:
return 0
if N == 1 or N == 2:
return 1
prev = 1 # N-2
curr = 1 # N-1
for i in range(3,N+1):
summ = prev + curr
prev = curr
curr = summ
return summ
return fib(N)
if __name__ == '__main__':
N = int(input())
c = func(N)
print(c)
for i in range(N+1):
print(func(i), end=" ")
作者:楚千羽
出处:https://www.cnblogs.com/chuqianyu/
本文来自博客园,本文作者:楚千羽,转载请注明原文链接:https://www.cnblogs.com/chuqianyu/p/16241655.html
本文版权归作者和博客园共有,欢迎转载,但未经作者同意必须在文章页面给出原文连接,否则保留追究法律责任的权利!