泰波那契序列 Tn 定义如下:
T0 = 0, T1 = 1, T2 = 1, 且在 n >= 0 的条件下 Tn+3 = Tn + Tn+1 + Tn+2
给你整数 n,请返回第 n 个泰波那契数 Tn 的值。
示例 1:
输入:n = 4
输出:4
解释:
T_3 = 0 + 1 + 1 = 2
T_4 = 1 + 1 + 2 = 4
示例 2:
输入:n = 25
输出:1389537
提示:
0 <= n <= 37
答案保证是一个 32 位整数,即 answer <= 2^31 - 1。
第 N 个泰波那契数
方法一:动态规划
泰波那契数的边界条件是 T(0)=0, T(1)=1, T(2)=1T(0)=0,T(1)=1,T(2)=1。当 n>2n>2 时,每一项的和都等于前三项的和,因此有如下递推关系:
T(n)=T(n-1)+T(n-2)+T(n-3)
T(n)=T(n−1)+T(n−2)+T(n−3)
由于泰波那契数存在递推关系,因此可以使用动态规划求解。动态规划的状态转移方程即为上述递推关系,边界条件为 T(0)T(0)、T(1)T(1) 和 T(2)T(2)。
根据状态转移方程和边界条件,可以得到时间复杂度和空间复杂度都是 O(n)O(n) 的实现。由于 T(n)T(n) 只和前三项有关,因此可以使用「滚动数组思想」将空间复杂度优化成 O(1)O(1)。如下的代码中给出的就是这种实现。
class Solution {
public int tribonacci(int n) {
if (n == 0) {
return 0;
}
if (n <= 2) {
return 1;
}
int p = 0, q = 0, r = 1, s = 1;
for (int i = 3; i <= n; ++i) {
p = q;
q = r;
r = s;
s = p + q + r;
}
return s;
}
}
一题四解 :「迭代」&「递归」&「矩阵快速幂」&「打表」
迭代实现动态规划
都直接给出状态转移方程了,其实就是道模拟题。
使用三个变量,从前往后算一遍即可。
代码:
class Solution {
public int tribonacci(int n) {
if (n == 0) return 0;
if (n == 1 || n == 2) return 1;
int a = 0, b = 1, c = 1;
for (int i = 3; i <= n; i++) {
int d = a + b + c;
a = b;
b = c;
c = d;
}
return c;
}
}
递归 => 记忆化搜索 => 动态规划
解题思路
本题是斐波那契数列的拓展,可以使用类似的思路。
本文分为 3 个部分,思路是 递归 => 记忆化搜索 => 动态规划。
递归
求第 n 个泰波那契数的时候需要知道第 n-1 个数、第 n-2 个数、第 n-3 个数,也就是大问题被拆解成了小问题,这很符合递归的逻辑。
斐波那契数列是我们学过的第一个递归问题,相信大家都会写。泰波那契数是个简单的拓展,很快我们就写出来下面的 python 代码:
class Solution(object):
def tribonacci(self, n):
if n == 0: return 0
if n == 1: return 1
if n == 2: return 1
return self.tribonacci(n - 1) + self.tribonacci(n - 2) + self.tribonacci(n - 3)
时间复杂度:O(3 ^ n)O(3
n
),类似于三叉树的节点数。
空间复杂度:O(n)O(n),栈的深度。
但是我们提交了之后,发现超时了。为什么呢?
因为,直接递归解法由于有很多的重复计算,比如计算 fib(4) 的时候需要计算 fib(3)、 fib(2) 和 fib(1);而计算 fib(5) 的时候,又计算了一遍 fib(4)、 fib(3) 和 fib(2) 。
记忆化搜索
为了解决重复计算的问题,可以使用「记忆化搜索」,它的思路是使用字典保存计算过的 fib(n)。当计算 fib(n + 1)的时候,就可以从字典中直接获取 fib(n),省去了重复的计算,所以速度很快。
Python 代码如下:
class Solution(object):
def __init__(self):
self.memo = {0:0, 1:1, 2:1}
def tribonacci(self, n):
if n in self.memo:
return self.memo[n]
res = self.tribonacci(n - 1) + self.tribonacci(n - 2) + self.tribonacci(n - 3)
self.memo[n] = res
return res
在 python3 中,可以使用语言自带的「记忆化搜索」的注解:@functools.lru_cache(),它的用法只有一行,即在要执行记忆化的函数上面加上一行注解,即可在语言级别的自动化的记忆化递归。
class Solution:
@functools.lru_cache()
def tribonacci(self, n: int) -> int:
if n == 0: return 0
if n == 1: return 1
if n == 2: return 1
return self.tribonacci(n - 1) + self.tribonacci(n - 2) + self.tribonacci(n - 3)
时间复杂度:O(n)O(n),因为避免了重复的计算。
空间复杂度:O(n)O(n),栈的深度。
使用简单的记忆化搜索,成功降低了时间复杂度,提交就能不再超时了。