每日算法1_2020-06-05

来源：题库 - 力扣 (LeetCode) (leetcode-cn.com)。侵删。

题目一

泰波那契序列 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。

我的解答

class Solution {
    public int tribonacci(int n) {
        int t[] = new int[n+1];
        t[0] = 0;
        t[1] = 1;
        t[2] = 1;
        int t_i;
        for(int i=3;i<=n;i++){
            t_i = t[i-3] + t[i-2] + t[i-1];
            t[i] = t_i;
        }
        return t[n];
    }
}

正确答案

class Solution {
    public int tribonacci(int n) {
        int t[] = new int[38];
        t[0] = 0;
        t[1] = 1;
        t[2] = 1;
        int t_i;
        for(int i=3;i<=n;i++){
            t_i = t[i-3] + t[i-2] + t[i-1];
            t[i] = t_i;
        }
        return t[n];
    }
}

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

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 个斐波那契数。

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

class Tri:
    def __init__(self):
        def helper(k):
            if k == 0:
                return 0
            
            if nums[k]:
                return nums[k]

            nums[k] = helper(k - 1) + helper(k - 2) + helper(k - 3) 
            return nums[k]
        
        n = 38
        self.nums = nums = [0] * n
        nums[1] = nums[2] = 1
        helper(n - 1)
                    
class Solution:
    t = Tri()
    def tribonacci(self, n: int) -> int:
        return self.t.nums[n]

复杂度分析

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

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

方法三：性能优化：动态计算

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];
  }
}

复杂度分析

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

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