最长斐波那契序列-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;
    }
}