力扣：73. 最长的斐波那契子序列的长度

最新推荐文章于 2025-12-11 15:34:25 发布

原创最新推荐文章于 2025-12-11 15:34:25 发布 · 153 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#leetcode #算法 #职场和发展

算法同时被 2 个专栏收录

278 篇文章

订阅专栏

菜鸟刷题记录

204 篇文章

订阅专栏

本文介绍了一种Java解决方案来寻找给定整数数组中的最长斐波那契子序列，通过对比了使用Set、记忆化搜索和动态规划三种方法的效率，展示了如何利用空间和时间 trade-off 来提升算法性能。



import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;

/**
 * @author xnl
 * @Description:
 * @date: 2022/7/9   21:04
 */
public class Solution {
    public static void main(String[] args) {
        Solution solution = new Solution();
        int[] arr = {1,2,3,4,5,6,7,8};
        System.out.println(solution.lenLongestFibSubseq(arr));
    }

    /**
     * 使用map
     * @param arr
     * @return
     */
    public int lenLongestFibSubseq(int[] arr) {
        int res = 0;
        Set<Integer> set = new HashSet<>();
        for (int i : arr) {
            set.add(i);
        }

        for (int i = 0; i < arr.length; i++){
            for (int j = i + 1; j < arr.length; j++){
                int num1 = arr[i];
                int num2 = arr[j];
                int count = 2;
                while (set.contains(num1 + num2)){
                    int temp = num1 + num2;
                    num1 = num2;
                    num2 = temp;
                    count++;
                }
                if (count > 2){
                    res = Math.max(count, res);
                }
            }
        }
        return res;
    }

    /**
     * 记忆化搜索，把搜索的结果记录下来，避免重复操作，以空间换取时间
     * @param arr
     * @return
     */
    public int lenLongestFibSubseq2(int[] arr) {
        int res = 0;
        int n = arr.length;
        Map<Integer, Integer> map = new HashMap<>(n);

        for (int i = 0; i < n; i++){
            map.put(arr[i], i);
        }

        // 记忆化数组
        int[][] memo = new int[n][n];
        for (int i = 0; i < n; i++){
            for (int j = i + 1; j < n; j++){
                int m = dfs(i ,j , arr, memo, map);
                if (m > 2){
                    res = Math.max(res, m);
                }
            }
        }
        return res;
    }

    private int dfs(int i, int j ,int[] arr, int[][] memo, Map<Integer, Integer> map){
        if (memo[i][j] > 0){
            return memo[i][j];
        }

        int temp = arr[i] + arr[j];
        memo[i][j] = 2;
        if (map.containsKey(temp)){
            memo[i][j] = 1 + dfs(j, map.get(temp), arr, memo, map );
        }
        return memo[i][j];
    }

    /**
     * 动态规划
     *  动态转移方程：假如说 在 i j 之前有一个k ,那么说  j - i = k;
     *  可以在arr[i][j] 上面记录我们的结果，所有动态转移方程就是一直记录之前的值
     * @param arr
     * @return
     */
    public int lenLongestFibSubseq3(int[] arr) {
        int res = 0;
        Map<Integer, Integer> map = new HashMap<>();
        int n = arr.length;
        for (int i = 0; i < n; i++){
            map.put(arr[i], i);
        }

        int[][] dp = new int[n][n];
        for (int i = 0; i < n ;i ++){
            for (int j = i - 1; j >= 0 && j + 2 > res; j--){
                if (arr[i] - arr[j] >= arr[j]){
                    break;
                }
                int diff = map.getOrDefault(arr[i] - arr[j], -1);
                if (diff == -1){
                    continue;
                }
                dp[i][j] = Math.max(3, dp[i][j] + 1);
                res = Math.max(res, dp[i][j]);
            }
        }

        return res ;
    }
}