最长斐波那契序列-LeetCode-873

英文版
A sequence X_1, X_2, ..., X_n is fibonacci-like if:

- n >= 3
- X_i + X_{i+1} = X_{i+2} for all i + 2 <= n

Given a strictly increasing array A of positive integers forming a sequence, find the length of the longest fibonacci-like subsequence of A. If one does not exist, return 0.

(Recall that a subsequence is derived from another sequence A by deleting any number of elements (including none) from A, without changing the order of the remaining elements. For example, [3, 5, 8] is a subsequence of [3, 4, 5, 6, 7, 8].)

Example 1:

Input: [1,2,3,4,5,6,7,8]
Output: 5
Explanation:
The longest subsequence that is fibonacci-like: [1,2,3,5,8].

Example 2:

Input: [1,3,7,11,12,14,18]
Output: 3
Explanation:
The longest subsequence that is fibonacci-like:
[1,11,12], [3,11,14] or [7,11,18].

Note:

• - 3 <= A.length <= 1000
• - 1 <= A[0] < A[1] < ... < A[A.length - 1] <= 10^9

(The time limit has been reduced by 50% for submissions in Java, C, and C++.)

中文版：
给你一个严格单调递增的数组，请问数组里最长的斐波那契序列的长度是多少？例如，如果输入的数组是[1, 2, 3, 4, 5, 6, 7, 8]，由于其中最长的斐波那契序列是1, 2, 3, 5, 8，因此输出应该是5。

分析：

思路一
在斐波那契序列中，第n个数字等于第n-1个数字与第n-2个数字之和。

考虑以数组中第i个数字(记为A[i])为结尾的最长斐波那契序列的长度。对于每一个j（0 <= j < i），A[j]都有可能是在某个斐波那契序列中A[i]前面的一个数字。如果存在一个k（k < j）满足A[k] + A[j] = A[i]，那么这三个数字就组成了一个斐波那契序列。这个以A[i]为结尾、前一个数字是A[j]的斐波那契序列是在以A[j]为结尾、前一个数字是A[k]的序列的基础上增加了一个数字A[i]，因此前者的长度是在后者的长度基础上加1。

我们可以用一个二维数组lengths来记录斐波那契序列的长度。二维数组中第i行第j列数字的含义是以输入数组中A[i]结尾、并且前一个数字是A[j]的斐波那契序列的长度。如果存在一个数字k，满足A[k] + A[j] = A[i]，那么lengths[i][j] = lengths[j][k] + 1。如果不存在满足条件的k，那么意味这A[j]、A[i]不在任意一个斐波那契序列中,lengths[i][j]等于2。

二维数组lengths中的最大值就是输出值。

 class Solution {
     public int lenLongestFibSubseq(int[] A) {
         if (null == A || A.length == 0) {
             return 0;
         }
         Map<Integer, Integer> map = new HashMap<>();
         for (int i = 0; i < A.length; i ++) {
             map.put(A[i], i);
         }

         int[][] lengths = new int[A.length][A.length];
         int maxLength = 1;
         for (int i = 1; i < A.length; i ++) {
             int num_3 = A[i];
             int length = 2;
             for (int j = i-1; j >= 0; j --) {
                 int num_2 = A[j];
                 int num_1 = num_3 - num_2;

                 int len = 2;
                 if (num_1 < num_2 && map.containsKey(num_1)) {
                     len = lengths[j][map.get(num_1)] + 1;
                 }
                 lengths[i][j] = len;
                 length = Math.max(length, len);
             }
             maxLength = Math.max(maxLength, length);
         }
         return maxLength > 2 ? maxLength : 0;
     }
 }

思路二
双重循环枚举所有可能的情况

 class Solution {
     public int lenLongestFibSubseq(int[] A) {
         int N = A.length;
         Set<Integer> S = new HashSet();
         for (int x: A) S.add(x);

         int ans = 0;
         for (int i = 0; i < N; ++i)
             for (int j = i+1; j < N; ++j) {
                 int x = A[j], y = A[i] + A[j];
                 int length = 2;
                 while (S.contains(y)) {
                     // x, y -> y, x+y
                     int tmp = y;
                     y += x;
                     x = tmp;
                     ans = Math.max(ans, ++length);
                 }
             }

         return ans >= 3 ? ans : 0;
     }
 }