leetcode873. 最长的斐波那契子序列的长度

如果序列 X_1, X_2, ..., X_n 满足下列条件，就说它是 斐波那契式 的：

• n >= 3
• 对于所有 i + 2 <= n，都有 X_i + X_{i+1} = X_{i+2}

给定一个严格递增的正整数数组形成序列，找到 A 中最长的斐波那契式的子序列的长度。如果一个不存在，返回  0 。

（回想一下，子序列是从原序列 A 中派生出来的，它从 A 中删掉任意数量的元素（也可以不删），而不改变其余元素的顺序。例如， [3, 5, 8] 是 [3, 4, 5, 6, 7, 8] 的一个子序列）

 

示例 1：

输入: [1,2,3,4,5,6,7,8]
输出: 5
解释:
最长的斐波那契式子序列为：[1,2,3,5,8] 。

示例 2：

输入: [1,3,7,11,12,14,18]
输出: 3
解释:
最长的斐波那契式子序列有：
[1,11,12]，[3,11,14] 以及 [7,11,18] 。

 

提示：

• 3 <= A.length <= 1000
• 1 <= A[0] < A[1] < ... < A[A.length - 1] <= 10^9
• （对于以 Java，C，C++，以及 C# 的提交，时间限制被减少了 50%）

 

 

对于此题，首先想到的是dfs搜索，搜索每一个斐波那契数列，遇到更长的就记录下来。

但是我们会发现，对于一个数列比如1,2,3,5,8.....我们从5开始搜索最终得到和从8搜索一样的结果，这就产生了重复计算，

因此我们要采取动态规划，而不是dfs搜索。

我们假设dp[i][j]是以A【i】与A【j】结尾的数列（因为默认了Ai<Aj）。

所以对于类似......A[i],A[j]这个数列如果有A[k]==A[i]+A[j]，那么这数列就变成了.....A[i],A[j],A[k].

dp[j][k]=dp[i][j]+1

上述式子便是转移方程。

我们考虑初始化的情况：对于dp[i][i]意思是两个相同的数字做结尾，是不存在的！因此dp[i][i]=0

而其他的情况，只要处于两个不同的式子，那么长度就是2.所以dp【i】【j】=2，

依靠转移方程，我们可以得到如下的代码：

class Solution:
    def lenLongestFibSubseq(self, A):
        """
        :type A: List[int]
        :rtype: int
        """
        if not A:
            return 0
        d={}
        for i in range(len(A)):
            d[A[i]]=i
        dp=[[1 if x==y else 2 for x in range(len(A))] for y in range(len(A))]
        ans=0
        for i in range(len(A)):
            for j in range(i+1,len(A)):
                t=A[i]+A[j]
                if d.get(t,-1)!=-1:
                    k=d[t]
                    dp[j][k]=max(dp[j][k],dp[i][j]+1)
                    ans=max(dp[j][k],ans)
        return ans

字典d是值-下标映射，为了更快的查找下标k。

经过我的测试，这个代码是能通过除了最后两三组最大数据的所有测试。

然后我参考了其他代码：

class Solution(object):
    def lenLongestFibSubseq(self, A):
        """
        :type A: List[int]
        :rtype: int
        """
        vset = set(A)
        dp = collections.defaultdict(lambda: collections.defaultdict(int))
        size = len(A)
        ans = 0
        for i in range(size):
            x = A[i]
            for j in range(i + 1, size):
                y = A[j]
                if x + y not in vset: continue
                dp[y][x + y] = max(dp[y][x + y], dp[x][y] + 1)
                ans = max(dp[y][x + y], ans)
        return ans and ans + 2 or 0

来源：http://bookshadow.com/weblog/2018/07/22/leetcode-length-of-longest-fibonacci-subsequence/

这个作者用x，y分别代表A【i】，A【j】然后用二元默认字典来收集数据。

但是，最开始我的代码里dp的构造是确确实实花费了平方的时间了。（但是set与dict速度几乎相同）

所以相当于省去了半个O（n^2）时间。

最终下面的代码可以通过测试。