1137. 第 N 个泰波那契数

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

方法一：空间优化：动态计算

• 如果 n < 3，答案可直接得出。

• 否则，初始化前 3 个斐波那契数字 x = 0, y = z = 1，并执行 n - 2 步循环。循环的每一步：

• • 令 x = y。

  • 令 y = z。

  • 令 z = x + y + z。

  • 返回z。

class Solution {
  public int tribonacci(int n) {
    if (n < 3) return n == 0 ? 0 : 1;

    int tmp, x = 0, y = 1, z = 1;
    for (int i = 3; i <= n; ++i) {
      tmp = x + y + z;
      x = y;
      y = z;
      z = tmp;
    }
    return z;
  }
}

复杂度分析

• 时间复杂度：O(N)。

• 空间复杂度：O(1)，保存最后 3 个斐波那契数。

方法二：性能优化：带记忆的递归

预计算 38 个斐波那契数：

• 初始化一个数组 nums 用于保存斐波那契数，并记录前 3 个斐波那契数。

• 返回 helper(n - 1)。

递归方法 helper(k)：

• 如果 k == 0，返回 0。
• 如果 nums[k] != 0，返回 nums[k]。
• 否则 nums[k] = helper(k - 1) + helper(k - 2) + helper(k - 3)，返回 nums[k]。

从预计算的数组中检索所需的斐波那契数。

class Tri {
  private int n = 38;
  public int[] nums = new int[n];

  int helper(int k) {
    if (k == 0) return 0;
    if (nums[k] != 0) return nums[k];

    nums[k] = helper(k - 1) + helper(k - 2) + helper(k - 3);
    return nums[k];
  }

  Tri() {
    nums[1] = 1;
    nums[2] = 1;
    helper(n - 1);
  }
}

class Solution {
  public static Tri t = new Tri();
  public int tribonacci(int n) {
    return t.nums[n];
  }
}

复杂度分析

时间复杂度：O(1)，预计算 38 个斐波那契数，并在数组中检索。

空间复杂度：O(1)，存储 38 个斐波那契数的数组。

方法三：性能优化：动态计算
　　预计算 38 个斐波那契数：

　　初始化一个数组用于保存斐波那契数，并初始化前 3 个斐波那契数字。

　　i 从 3 循环到 38，每一步计算出一个新的斐波那契数：nums[i] = helper(i - 1) + helper(i - 2) + helper(i - 3)。

　　从数组中检索所需的斐波那契数。

class Tri {
  private int n = 38;
  public int[] nums = new int[n];
  Tri() {
    nums[1] = 1;
    nums[2] = 1;
    for (int i = 3; i < n; ++i)
      nums[i] = nums[i - 1] + nums[i - 2] + nums[i - 3];
  }
}

class Solution {
  public static Tri t = new Tri();
  public int tribonacci(int n) {
    return t.nums[n];
  }
}