g0801_0900.s0873_length_of_longest_fibonacci_subsequence.Solution Maven / Gradle / Ivy

Go to download

Show more of this group Show more artifacts with this name
Show all versions of leetcode-in-java21 Show documentation

Java-based LeetCode algorithm problem solutions, regularly updated

There is a newer version: 1.38

package g0801_0900.s0873_length_of_longest_fibonacci_subsequence;

// #Medium #Array #Hash_Table #Dynamic_Programming
// #2022_03_28_Time_120_ms_(92.64%)_Space_115.6_MB_(63.42%)

/**
 * 873 - Length of Longest Fibonacci Subsequence\.
 *
 * Medium
 *
 * A sequence x₁, x₂, ..., 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 `arr` of positive integers forming a sequence, return _the **length** of the longest Fibonacci-like subsequence of_ `arr`. If one does not exist, return `0`.
 *
 * A **subsequence** is derived from another sequence `arr` by deleting any number of elements (including none) from `arr`, 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:** arr = [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:** arr = [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].
 *
 * **Constraints:**
 *
 * *   `3 <= arr.length <= 1000`
 * *   1 <= arr[i] < arr[i + 1] <= 10⁹
**/
public class Solution {
    public int lenLongestFibSubseq(int[] arr) {
        if (arr == null || arr.length < 3) {
            return 0;
        }
        int len = arr.length;
        int[][] dp = new int[len][len];
        int ans = 0;
        for (int i = 2; i < len; i++) {
            int left = 0;
            int right = i - 1;
            while (left < right) {
                if (arr[left] + arr[right] < arr[i]) {
                    left++;
                } else if (arr[left] + arr[right] > arr[i]) {
                    right--;
                } else {
                    // dp[right][i] = Math.max(dp[right][i], dp[left][right] + 1);
                    dp[right][i] = dp[left][right] + 1;
                    ans = Math.max(ans, dp[right][i]);
                    left++;
                    right--;
                }
            }
        }
        return ans > 0 ? ans + 2 : 0;
    }
}