剑指 Offer II 093. 最长斐波那契数列（873. 最长的斐波那契子序列的长度）

题目：

 

思路：

【1】动态规划的方式

代码展示：

动态规划的方式：

//时间86 ms击败50.28%
//内存50.7 MB击败30.31%
//时间复杂度：O(n^2)，其中 n 是数组 arr 的长度。动态规划的状态数是 O(n^2)，每个状态的计算时间都是 O(1)。
//空间复杂度：O(n^2)，其中 n 是数组 arr 的长度。需要创建二维数组 dp，空间是 O(n^2)。
class Solution {
    public int lenLongestFibSubseq(int[] arr) {
        Map<Integer, Integer> indices = new HashMap<Integer, Integer>();
        int n = arr.length;
        for (int i = 0; i < n; i++) {
            indices.put(arr[i], i);
        }
        int[][] dp = new int[n][n];
        int ans = 0;
        for (int i = 0; i < n; i++) {
            for (int j = i - 1; j >= 0 && arr[j] * 2 > arr[i]; j--) {
                int k = indices.getOrDefault(arr[i] - arr[j], -1);
                if (k >= 0) {
                    dp[j][i] = Math.max(dp[k][j] + 1, 3);
                }
                ans = Math.max(ans, dp[j][i]);
            }
        }
        return ans;
    }
}


//时间51 ms击败100%
//内存50.3 MB击败57.17%
class Solution {
    public int lenLongestFibSubseq(int[] arr) {
        int[][] dp = new int[arr.length][arr.length];
        int max = 0;
        for (int i = 2; i < arr.length; i++) {
            int low = 0;
            int high = i - 1;
            while (low < high) {
                if (arr[low] + arr[high] > arr[i])
                    high--;
                else if (arr[low] + arr[high] < arr[i])
                    low++;
                else {
                    dp[high][i] = Math.max(dp[high][i], dp[low][high] + 1);
                    max = Math.max(max, dp[high][i] + 2);
                    low++;
                    high--;
                }
            }
        }
        return max;
    }
}