【数学】最长的斐波那契子序列的长度-动态规划

题目描述

如果一个序列：X_1,X_2,...X_n 满足以下条件，就说它是 斐波那契 数列，要求如下：

• n>=3
• 对于所有 i+2 <= n，都有 X_i + X_{i+1} = X_{i+2}

给定一个严格递增的正整数数组形成序列 arr ，找到 arr 中最长的斐波那契式的子序列的长度。如果一个不存在，返回  0 。

示例1:

输入: arr = [1,2,3,4,5,6,7,8]

输出: 5

解释: 最长的斐波那契式子序列为 [1,2,3,5,8] 。

解题思路 

思路1

进行循环遍历；举例：arr = [1,2,3,4,5,6,7,8]，将这些数字放到HashSet种，取数字

• (1,2),(1,3),(1,4),(1,5),(1,6),(1,7),(1,8),
• (2,3),(2,4),(2,5),(2,6),(2,7),(2,8),
• (3,4),(3,5),(3,6),(3,7),(3,8),
  
• (4,5),(4,6),(4,7),(4,8),
  
• (5,6),(5,7),(5,8),
• (6,7),(6,8),
• (7,8),

获取到这个数字列表后，按照规则计算 int v = arr[0] + arr[1], 如果HashSet中存在这个数字则重复计算，并统计满足条件的数量；

代码实现如下：

import java.util.TreeSet;

class Solution1 {

    public int lenLongestFibSubseq(int[] arr) {

        TreeSet<Integer> set = new TreeSet<>();
        for (int v : arr) {
            set.add(v);
        }
        int max = 2;
        for (int i = 0; i < arr.length; i++) {
            for (int j = i + 1; j < arr.length; j++) {
                max = Math.max(max, f(arr[i], arr[j], set));
            }
        }
        return max>2 ? max:0;
    }

    private int f(int a0, int a1, TreeSet<Integer> set) {

        int count = 2;
        int a3 = a0 + a1;

        while (set.contains(a3)) {
            count++;
            a0 = a1;
            a1 = a3;
            a3 = a0 + a1;
        }
        return count;
    }
}

这个可以做一下优化，判断这个通过一个visited数组判断是否访问过，如果访问过则直接返回，这样计算耗时会下降，优化后代码如下：

import java.util.HashMap;
import java.util.Map;

class Solution2 {

    boolean[][] visited;
    int[] arr;
    public int lenLongestFibSubseq(int[] arr) {

        this.visited = new boolean[arr.length][arr.length];
        this.arr = arr;

        Map<Integer, Integer> map = new HashMap<>();
        for (int i = 0; i < arr.length; i++) {
            int v = arr[i];
            map.put(v, i);
        }
        int max = 2;
        for (int i = 0; i < arr.length; i++) {
            for (int j = i + 1; j < arr.length; j++) {
                max = Math.max(max, f(i, j, map));
            }
        }
        return max > 2 ? max : 0;
    }

    private int f(int i, int j, Map<Integer, Integer> map) {

        if (visited[i][j]) {
            return 2;
        }
        int count = 2;
        int a3 = arr[i] + arr[j];
        while (map.get(a3) != null) {
            visited[i][j] = true;
            count++;
            i = j;
            j = map.get(a3);
            a3 = arr[i] + arr[j];
            if (visited[i][j]) {
                break;
            }

        }
        return count;
    }
}

思路2

动态规划，核心计算公式：dp[k][j] = max(dp[j][i],3)；其中i、j、k代表具体的下标。在文章中找到的解决思路是通过arr[k] - arr[j] 是否能找到对应的i，并且arr[k] > arr[j] > arr[i]，具体实现代码如下：

import java.util.HashMap;
import java.util.Map;

class Solution {

    public int lenLongestFibSubseq(int[] arr) {
        int n = arr.length;
        int ans = 0;
        Map<Integer, Integer> map = new HashMap<>();
        for (int i = 0; i < n; i++) {
            map.put(arr[i], i);
        }
        int[][] dp = new int[n][n];

        for (int j = 0; j < n; j++) {
            for (int k = j + 1; k < n; k++) {
                int a_i = arr[k] - arr[j];
                // 这个是做了优化，保证 arr[i]<arr[j]<arr[k]
                if (a_i >= arr[j]) {
                    break;
                }

                Integer i = map.get(a_i);
                if (i != null) {
                    dp[k][j] = Math.max(dp[j][i] + 1, 3);
                }
                ans = Math.max(ans, dp[k][j]);
            }
        }
        return ans;
    }

}

总结

这道题是一道数学+动态规划的题目，如果不使用动态规划我这边耗时优化后也要200ms，使用动态规划后验证只要70ms。对于动态规划的题目，还是多加练习，从看得懂到会做想得到，最后是写的出来。