【LeetCode】动态规划—1027. 最长等差数列（附完整Python/C++代码）

前言

最长等差子序列问题是一种经典的动态规划问题，要求找到给定整数数组中元素之间有固定差值的最长子序列。该问题的难点在于，如何在每次找到满足等差条件的同时，最大化子序列的长度。通过结合哈希表或数组来存储中间结果，我们可以高效地解决这一问题。

---

题目描述

---

基本思路

1. 问题定义

给定一个整数数组 nums，返回其中最长的等差子序列的长度。等差子序列是指一个子序列，其中任意相邻的两个元素之间的差值是相同的。

2. 理解问题和递推关系

为了找到最长的等差子序列，我们可以将问题转化为动态规划问题，存储在 dp 表中，其中 dp[i][d] 表示以 nums[i] 结尾且公差为 d 的最长等差子序列的长度。

动态规划状态转移：

• 对于每一个 nums[i]，我们检查之前的所有元素 nums[j]（j < i），并计算两个元素之间的差值 diff = nums[i] - nums[j]。
• 如果 nums[j] 和 nums[i] 的差值是 diff，那么 dp[i][diff] 就可以通过 dp[j][diff] 来更新：
  $$dp[i][diff]=dp[j][diff]+1$$
  • 如果 dp[j][diff] 不存在，则以 nums[i] 和 nums[j] 开始的子序列的长度为 2（因为至少包含两个元素）。
  • 否则，更新 dp[i][diff] 的值。

初始条件：

• 每个元素 nums[i] 可以单独作为等差子序列的起点，因此初始状态为 dp[i][diff] = 1。

最终答案：

• 遍历所有的 dp[i][diff]，返回其中的最大值。

3. 解决方法

动态规划 + 哈希表

1. 使用 dp[i] 表示以 nums[i] 结尾的等差子序列，dp[i][d] 是哈希表，表示以 nums[i] 结尾且公差为 d 的最长子序列长度。
2. 遍历数组 nums 的每个元素，计算与之前所有元素的差值 diff，更新哈希表 dp[i][d]。

4. 进一步优化

• 可以通过将状态存储在哈希表中来处理负差值以及较大的差值，从而避免数组越界。
• 由于每个 nums[i] 需要与之前的所有元素进行比较，因此时间复杂度为 O(n^2)。

5. 小总结

• 本问题的核心是通过动态规划将问题转化为子问题，通过存储前一个状态的结果来优化整体的计算效率。
• 动态规划配合哈希表的方式能够有效地记录每个位置的状态，从而找到最长的等差子序列。

以上就是最长等差数列问题的基本思路。

---

Python代码

class Solution:
    def longestArithSeqLength(self, nums: list[int]) -> int:
        # dp[i] 是一个哈希表，表示以 nums[i] 结尾的等差子序列
        dp = [{} for _ in range(len(nums))]
        max_len = 2  # 初始化最长长度至少为2，因为至少有两个元素构成等差序列

        for i in range(1, len(nums)):
            for j in range(i):
                diff = nums[i] - nums[j]  # 计算差值
                # 如果以 nums[j] 结尾的子序列存在这个差值，则继承长度
                if diff in dp[j]:
                    dp[i][diff] = dp[j][diff] + 1
                else:
                    dp[i][diff] = 2  # 至少有两个元素构成等差序列

                # 更新最大长度
                max_len = max(max_len, dp[i][diff])

        return max_len

Python 代码解释总结

1. 哈希表 dp[i]：每个 dp[i] 是一个哈希表，存储以 nums[i] 结尾且差值为 d 的最长等差子序列长度。
2. 双重循环遍历：对于每个 nums[i]，遍历其之前的所有元素，计算差值 diff，并更新当前的哈希表 dp[i]。
3. 返回最大值：最终返回 max_len，即为最长等差子序列的长度。

---

C++代码

class Solution {
public:
    int longestArithSeqLength(vector<int>& nums) {
        int n = nums.size();
        if (n < 2) return n;

        // dp[i] 是一个哈希表，表示以 nums[i] 结尾的等差子序列
        vector<unordered_map<int, int>> dp(n);
        int max_len = 2;  // 初始化最长长度至少为2

        for (int i = 1; i < n; ++i) {
            for (int j = 0; j < i; ++j) {
                int diff = nums[i] - nums[j];  // 计算差值
                // 如果以 nums[j] 结尾的子序列存在这个差值，则继承长度
                if (dp[j].count(diff)) {
                    dp[i][diff] = dp[j][diff] + 1;
                } else {
                    dp[i][diff] = 2;  // 至少有两个元素构成等差序列
                }
                // 更新最大长度
                max_len = max(max_len, dp[i][diff]);
            }
        }

        return max_len;
    }
};

C++ 代码解释总结：

1. 哈希表 dp[i]：dp[i] 是一个 unordered_map，表示以 nums[i] 结尾且公差为 d 的最长等差子序列长度。
2. 双重循环遍历：对于每个 nums[i]，遍历之前的所有元素，计算差值 diff，并更新 dp[i]。
3. 返回最大值：最终返回最长等差子序列的长度 max_len。

---

总结

• 该问题使用动态规划结合哈希表的方式，将问题转化为计算每个位置能够形成的最长等差子序列的长度。
• 通过记录每个元素的等差子序列状态，可以高效地解决问题，时间复杂度为 O(n^2)。
• 这类问题非常适合动态规划，因为通过记录子问题的结果，能够避免重复计算并优化复杂度。