【LeetCode】动态规划—1218. 最长定差子序列（附完整Python/C++代码）

前言

在许多动态规划问题中，使用哈希表优化查询和更新操作是常见的技巧。最长等差子序列问题正是其中的一个例子，它要求我们找到给定数组中符合特定差值的最长子序列。通过动态规划结合哈希表，我们可以有效地解决这个问题，并降低时间复杂度。

题目描述

基本思路

1. 问题定义

给定一个整数数组 arr 和一个整数 difference，需要找到数组中最长的等差子序列，该子序列中的任意两个相邻元素之差等于 difference。最后返回子序列的长度。

2. 理解问题和递推关系

定义：

• 等差子序列是指一个子序列，其中任意两个相邻元素的差等于给定的 difference。
• 需要找出在 arr 中满足上述条件的最长子序列的长度。

思路：

可以通过动态规划的思想来解决这个问题。使用一个哈希表 dp 来记录以某个元素为末尾的最长等差子序列的长度。对于每个 arr[i]，我们尝试找到 arr[i] - difference 是否已经出现过。如果存在 arr[i] - difference，则 arr[i] 可以连接在这个子序列后，形成一个新的、更长的等差子序列。

递推关系：

• 设 dp[x] 表示以元素 x 结尾的最长等差子序列的长度。
• 对于每个 arr[i]，如果 arr[i] - difference 在哈希表中已经存在，那么可以连接在该序列后，因此：
  $$dp[arr[i]]=dp[arr[i]-difference]+1$$
• 如果 arr[i] - difference 不存在，则说明以 arr[i] 结尾的子序列长度为 1，即只有该元素自身组成的序列：
  $$dp[arr[i]]=1$$
• 最终答案是所有 dp 值中的最大值。

3. 解决方法

3.1 动态规划 + 哈希表

1. 遍历数组 arr，对于每一个 arr[i]：
   • 如果 arr[i] - difference 存在于 dp 哈希表中，则 dp[arr[i]] = dp[arr[i] - difference] + 1。
   • 否则 dp[arr[i]] = 1。
2. 记录过程中出现的最大值，即为最终结果。

3.2 优化

• 使用哈希表可以将时间复杂度优化为 O(n)，因为每个元素只需要常数时间来更新哈希表。

4. 进一步优化

由于我们只需要遍历一次数组，并对每个元素在哈希表中进行查询和更新，因此该算法已经是最优解。通过哈希表实现，可以将时间复杂度保持在 O(n)，空间复杂度也是 O(n)。

5. 小总结

• 本问题的本质是通过动态规划和哈希表来跟踪每个元素作为子序列末尾时的最长子序列长度。
• 动态规划解决了通过递推公式计算出最长等差子序列，而哈希表优化了查询和更新的效率。

以上就是最长定差子序列问题的基本思路。

代码实现

Python

Python3代码实现

class Solution:
    def longestSubsequence(self, arr: list[int], difference: int) -> int:
        dp = {}  # 创建哈希表来存储每个元素结尾的最长等差子序列长度
        
        max_len = 0  # 初始化最长长度
        
        for num in arr:
            # 如果 num - difference 存在于 dp 中，计算以 num 为结尾的最长子序列长度
            if num - difference in dp:
                dp[num] = dp[num - difference] + 1
            else:
                dp[num] = 1  # 否则以 num 自身为一个子序列
            
            # 更新最大长度
            max_len = max(max_len, dp[num])
        
        return max_len

Python 代码解释

1. 哈希表 dp：dp[num] 表示以 num 结尾的最长等差子序列的长度。
2. 遍历 arr：对于每个元素 num，检查 num - difference 是否在 dp 中。如果存在，表示可以将当前元素接到这个序列后；否则，当前元素构成一个新的子序列。
3. 返回结果：返回最大长度 max_len。

C++

C++代码实现

class Solution {
public:
    int longestSubsequence(vector<int>& arr, int difference) {
        unordered_map<int, int> dp;  // 使用哈希表存储以每个元素为结尾的最长等差子序列长度
        int max_len = 0;  // 初始化最大长度
        
        for (int num : arr) {
            if (dp.find(num - difference) != dp.end()) {
                // 如果 num - difference 存在于哈希表中，更新 num 的最长子序列长度
                dp[num] = dp[num - difference] + 1;
            } else {
                dp[num] = 1;  // 否则，当前 num 本身就是一个长度为 1 的子序列
            }
            
            max_len = max(max_len, dp[num]);  // 更新最大长度
        }
        
        return max_len;
    }
};

C++ 代码解释

1. 哈希表 dp：用 unordered_map 来存储每个数结尾的最长等差子序列长度。
2. 遍历 arr：对于每个数 num，检查 num - difference 是否在 dp 中。如果存在，表示可以扩展等差子序列；否则，num 自己作为长度为 1 的子序列。
3. 返回结果：返回最大长度 max_len。

---

总结

• 本文详细介绍了如何通过动态规划结合哈希表来解决 最长等差子序列问题，并且通过 $O(n)$ 的时间复杂度获得最优解。
• 在这种类型的问题中，哈希表提供了高效的查询和更新功能，使得动态规划的状态转移更加高效。
• 掌握这种方法，不仅可以解决该问题，还可以应用于许多类似的子序列和差值问题。