斐波那契子序列的长度：揭秘最长子序列的奥秘

2024-02-20 08:19:38







## 斐波那契子序列的魅力

斐波那契子序列是一种数字序列，每个数字都是前两个数字之和。斐波那契子序列的开始是0和1，接下来是1、1、2、3、5、8、13、21，如此类推。斐波那契子序列在自然界和数学中都有着广泛的应用，从植物的生长到股票市场的波动，无处不见它的身影。

## 斐波那契子序列的长度

在LeetCode上有一个有趣的题目，要求我们找到一个给定序列中最长的斐波那契子序列的长度。为了解决这个问题，我们可以使用动态规划或递归的方法。

### 动态规划方法

动态规划是一种解决问题的策略，它将问题分解成更小的子问题，然后逐步解决这些子问题，最终得到问题的整体解决方案。对于这个问题，我们可以定义一个状态dp[i]，其中dp[i]表示以序列中的第i个数字结尾的最长斐波那契子序列的长度。然后，我们可以使用以下公式来计算dp[i]：

```java
dp[i] = max(dp[j] + 1) for all j < i and X_j + X_{j+1} = X_i

其中，max表示取最大值。这个公式的含义是，以序列中的第i个数字结尾的最长斐波那契子序列的长度等于以序列中的某个数字j结尾的最长斐波那契子序列的长度加上1，其中j必须小于i，并且X_j + X_{j+1} = X_i。

递归方法

递归是一种解决问题的策略，它将问题分解成更小的子问题，然后使用同样的方法来解决这些子问题。对于这个问题，我们可以使用以下递归公式来计算斐波那契子序列的长度：

fib(i) = max(fib(j) + 1) for all j < i and X_j + X_{j+1} = X_i

其中，fib(i)表示以序列中的第i个数字结尾的最长斐波那契子序列的长度。这个公式的含义与动态规划方法中的公式相同。

代码实现

我们可以使用Java语言来实现上述算法。以下是一个动态规划方法的Java实现：

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

        int[][] dp = new int[n][n];
        int maxLength = 0;
        for (int i = 1; i < n; i++) {
            for (int j = 0; j < i; j++) {
                int sum = arr[i] + arr[j];
                if (map.containsKey(sum) && map.get(sum) < i) {
                    dp[i][j] = dp[map.get(sum)][j] + 1;
                    maxLength = Math.max(maxLength, dp[i][j]);
                }
            }
        }

        return maxLength + 2;
    }
}

以下是一个递归方法的Java实现：

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

        int maxLength = 0;
        for (int i = 1; i < n; i++) {
            maxLength = Math.max(maxLength, fib(i, map, arr));
        }

        return maxLength + 2;
    }

    private int fib(int i, Map<Integer, Integer> map, int[] arr) {
        if (i == 0 || i == 1) {
            return 1;
        }

        int j = map.getOrDefault(arr[i] - arr[i - 1], -1);
        if (j >= 0 && j < i - 1) {
            return fib(j, map, arr) + 1;
        }

        return 1;
    }
}