1137. 第 N 个泰波那契数

泰波那契序列 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)，栈的深度。
使用简单的记忆化搜索，成功降低了时间复杂度，提交就能不再超时了。