dp 子序列问题-leetcode-1218. 最长定差子序列

最新推荐文章于 2024-09-13 18:11:35 发布

pospre

最新推荐文章于 2024-09-13 18:11:35 发布

阅读量183

点赞数

分类专栏： leetcode 文章标签： leetcode 算法动态规划

本文链接：https://blog.csdn.net/weixin_56915683/article/details/121166796

版权

leetcode 专栏收录该内容

77 篇文章 1 订阅

订阅专栏

这篇博客讨论了如何解决最长定差子序列问题。作者首先尝试了使用两层循环的动态规划方法，但发现对于大规模数据会导致超时。接着，作者优化了算法，通过创建一个大小为104的数组或使用哈希映射来存储以特定元素结尾的最长定差子序列长度，从而将时间复杂度降低到O(n)。博客详细介绍了这两种优化后的解决方案，并给出了它们的时间和空间复杂度分析。

摘要由CSDN通过智能技术生成

1218. 最长定差子序列

题目描述

给你一个整数数组 arr 和一个整数 difference，请你找出并返回 arr 中最长等差子序列的长度，该子序列中相邻元素之间的差等于 difference 。
子序列是指在不改变其余元素顺序的情况下，通过删除一些元素或不删除任何元素而从 arr 派生出来的序列。

提示：

$1 <= arr.length <= 10^5$
$10^4 <= arr[i], difference <= 10^4$

在这里插入图片描述

my dp code `tle`

一开始仿照 300. 最长递增子序列写法，使用 2 层 for 的 dp。

但是但是，由于本题 $1 <= arr.length <= 10^5$ ，所以 2 层 for 就 tle超时了。

// tle code
class Solution {
    public int longestSubsequence(int[] arr, int difference) {
        int n = arr.length;
        int[] dp = new int[n]; // dp[i]表示[0,i]内最长定差子序列长度
        int max = 0;
        for (int i = 1; i < n; i++) {
            for (int j = 0; j < i; j++) {
                // 2、递推公式
                if (arr[i] - arr[j] == difference) {
                    dp[i] = Math.max(dp[i], dp[j] + 1);
                }
                max = Math.max(max, dp[i]);
            }
        }
        // 打印dp
        System.out.println(Arrays.toString(dp));
        return max + 1;
    }
}

时间复杂度： $O(n^2)$
空间复杂度： $O (n)$

数组 + dp

由于题目中说了 $10^4 <= arr[i], difference <= 10^4$ ，所以可以开一个 $10^4$ 的数组。

状态转移方程：

dp[i + 20000] = Math.max(dp[i + 20000], dp[i + 20000 - difference] + 1);

最终，取所有 $d p [i]$ 的 max，即可。

class Solution {
    public int longestSubsequence(int[] arr, int difference) {
        int n = 40000;
        int[] dp = new int[n]; // dp[i]表示arr中以i元素结尾最长定差子序列长度
        int max = 0;
        for (int i : arr) {
            dp[i + 20000] = Math.max(dp[i + 20000], dp[i + 20000 - difference] + 1);
            max = Math.max(max, dp[i + 20000]);
        }
        // 打印dp
        // System.out.println(Arrays.toString(dp));
        return max;
    }
}

时间复杂度： $O (n)$
空间复杂度： $O(10^4)$

map + dp

由于本题数据量还是有点大，如何所给数组 arr 过于稀疏是，开 $10^4$ 的数组不免浪费空间。

所以，可以采用 map 来充当 dp 数组是更好的选择。

class Solution {
    public int longestSubsequence(int[] arr, int difference) {
        int n = 40000;
        Map<Integer, Integer> dp = new HashMap<>(); // dp[i]表示arr中以i元素结尾最长定差子序列长度
        int max = 0;
        for (int i : arr) {
            dp.put(i, dp.getOrDefault(i - difference, 0) + 1);
            max = Math.max(max, dp.get(i));
        }
        // 打印dp
        // System.out.println(Arrays.toString(dp));
        return max;
    }
}