【LeetCode】873. Length of Longest Fibonacci Subsequence 最长的斐波那契子序列的长度

题目

• A sequence $X_1,X_2,...,X_n$ is fibonacci-like if:

• $n\ge 3$
• $X_i+X_{i+1}=X_{i+2}foralli+2\le 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].)

Example1:
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\le A.length\le 1000$
• $1\le A[0]<A[1]<...<A[A.length-1]\le 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\le j<i$），A[j]都有可能出现在由A[i]结尾的某个斐波那契数列种，并且A[j]为A[i]的前面的一个数字。如果存在一个$k$($k<j$)满足A[k] + A[j] = A[i]，那么这三个数字就能组成一个斐波那契数列 { ⋅ ⋅ ⋅ , A [ k ] , A [ j ] , A [ i ] } \{\cdot\cdot\cdot, A[k], A[j], A[i]\} {⋅⋅⋅,A[k],A[j],A[i]}。 这个以A[i]为结尾，前面一个数字是A[j]的斐波那契额数列是在以A[j]为结尾、前一个数字为A[k]的序列的基础上增加了一个数字A[i]，因此以A[i]为结尾的斐波那契数列长度是以A[j]为结尾的斐波那契数列长度上加1.

可以使用一个二维数组dp来记录斐波那契系列的长度。二维数组中第i行第j列数据的含义是以输入数组中A[i]为口额为、并且前面一个数字是A[j]的斐波那契额序列的长度，如果存在一个数字k，满足$A[k]+A[j]=A[i]$，则$$dp[i][j]=Math.max(dp[j][k],2)+1$$如果不存在满足条件的k，那么A[i], A[j]不在仁义一个斐波那契序列中，则$dp[i][j]=0$。二维数组lengths中的最大值就是输出值。

Example:
设A[] = {1,2,3,4,5,6,7,8};

dp	index	0	1	2	3	4	5	6	7	maxLength
index	A	1	2	3	4	5	6	7	8
0	1									0
1	2	0								0
2	3	0	3							3
3	4	0	0	3						3
4	5	0	0	4	3					4
5	6	0	0	0	3	3				4
6	7	0	0	0	4	3	3			4
7	8	0	0	0	0	5	3	3		5

Explanation:

	dp[5][2] = 0: A[i = 5] = 6, A[j = 2] = 3, A[i = 5] - A[j = 2] = 3 = A[k = 2], k == j, jump  
	dp[5][1] = 0: A[i = 5] = 6, A[j = 1] = 2, A[i = 5] - A[j = 1] = 4 = A[k = 3], k > j， jump
	-------------------------------------------------------------------------------------------------------
	dp[2][1] = 3: A[i = 2] = 3, A[j = 1] = 2, A[i = 2] - A[j = 1] = 1 = A[k = 0],  k < j
	因此 dp[2][1] = Math.max(dp[1][0], 2) + 1 = 3
	
	dp[5][3] = 3: A[i = 5] = 6, A[j = 3] = 4, A[i = 5] - A[j = 3] = 2 = A[k = 1],  k < j
	因此 dp[5][3] = Math.max(dp[3][1], 2) + 1 = 3
	-------------------------------------------------------------------------------------------------------
	dp[4][2] = 4: A[i = 4] = 5, A[j = 2] = 3, A[i = 4] - A[j = 2] = 2 = A[k = 1],  k < j
	因此 dp[4][2] = Math.max(dp[2][1], 2) + 1 = 4
	dp[7][4] = 5: A[i = 7] = 8, A[j = 4] = 5, A[i = 7] - A[j = 4] = 3 = A[k = 2], k < j
	因为 dp[7][4] = Math.max(dp[4][2], 2) + 1 = 5

Example2
设A[] = {1,3,7,11,12,14,18};

dp	index	0	1	2	3	4	5	6	maxLength
index	A	1	3	7	11	12	14	18
0	1								0
1	3	0							0
2	7	0	0						0
3	11	0	0	0					0
4	12	0	0	0	3				3
5	14	0	0	0	3	0			3
6	18	0	0	0	3	0	0		3

具体实现（java）

public int lenLongestFibSubseq(int[] A) {
	int maxLength = 0;
    Map<Integer, Integer> map = new HashMap<>();
    for (int i = 0; i < A.length; i ++)    // 有数组中的值快速映射到该值对应的下标
    	map.put(A[i], i);
    int [][]dp = new int[A.length][A.length];
    for (int i = 1; i < A.length; i ++) {
    	for(int j = 0; j < i; j ++) {
    		int index = map.getOrDefault(A[i] - A[j], -1);      // 获得A[i] - A[j]，获得该值在数组中的位置
    		if(index >= 0 && index < j) {
    			dp[i][j] = Math.max(dp[j][index], 2) + 1;
    			maxLength = Math.max(maxLength, dp[i][j]);
    		}
    	}
    }
    return maxLength;
}