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

(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++.)

my solution.

Runtime: 935 ms, faster than 2.29% of Java online submissions for Length of Longest Fibonacci Subsequence.

我的思路，採用map，雖然也是dp，但是還是一個n2的時間複雜度，看了別人的做法，用的是頭尾指標逼近，二分法。今天的周賽裡判斷陣列成三角形的快速判斷方法也是這樣的。

class Solution {
  public int lenLongestFibSubseq(int[] A) {
    Map<Integer, Map<Integer,Integer>> mp = new HashMap<>();
    int ret = 0;
    for(int i=0; i<A.length; i++){
      if(i == 0) mp.put(A[i], new HashMap<>());
      else {
        mp.put(A[i],new HashMap<>());
        Map<Integer,Integer> mpai = mp.get(A[i]);
        for(int j=0; j<i; j++){
          Map<Integer,Integer> mpaj = mp.get(A[j]);
          mpai.put(A[j], mpaj.getOrDefault(A[i]-A[j],0)+1);
          ret = Math.max(ret, mpai.get(A[j]));
        }
      }
    }
    return ret > 1 ? ret + 1 : 0;
  }
}

網上的思路。

 Runtime: 41 ms, faster than 94.29% of Java online submissions for Length of Longest Fibonacci Subsequence.

class Solution {
  public int lenLongestFibSubseq(int[] A) {
    if(A.length < 3) return 0;
    int ret = 0;
    int[][] dp = new int[A.length][A.length];
    for(int i=2; i<A.length; i++){
      int left = 0, right = i-1;
      while(left < right){
        if(A[left] + A[right] == A[i]){
          dp[right][i] = dp[left][right]+1;
          ret = Math.max(ret, dp[right][i]);
          left++;
          right--;
        }else if(A[left] + A[right] > A[i]){
          right--;
        }else {
          left++;
        }
      }
    }
    return ret == 0 ? 0 : ret + 2;
  }
}