Leetcode.1027 最长等差数列

Posted 2023-04-05 感觉画质不如…原神

题目链接

Leetcode.1027 最长等差数列 Rating ： 1759

题目描述

给你一个整数数组 nums，返回 nums中最长等差子序列的长度。

回想一下，nums的子序列是一个列表 nums[i1], nums[i2], ..., nums[ik]，且 0 <= i1 < i2 < ... < ik <= nums.length - 1。并且如果 seq[i+1] - seq[i]( 0 <= i < seq.length - 1)的值都相同，那么序列 seq是等差的。

示例 1：

输入：nums = [3,6,9,12]
输出：4
解释：
整个数组是公差为 3 的等差数列。

示例 2：

输入：nums = [9,4,7,2,10]
输出：3
解释：
最长的等差子序列是 [4,7,10]。

示例 3：

输入：nums = [20,1,15,3,10,5,8]
输出：4
解释：
最长的等差子序列是 [20,15,10,5]。

提示：

• $2<=nums.length<=1000$
• $0<=nums[i]<=500$

解法：动态规划

我们定义 $f(i,d)$ 为选择以 nums[i]结尾的，公差为 d的，最大段数。（比如：1 , 2 , 3,就是 两段）

用 ans记录遍历过程中的最大值，最后返回 ans + 1。因为段数 + 1 才是长度。

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

C++代码：

class Solution 
public:
    int longestArithSeqLength(vector<int>& nums) 
        int n = nums.size();
        int f[n][1001];
        memset(f,0,sizeof f);

        int ans = 0;
        for(int i = 0;i < n;i++)
            for(int j = 0;j < i;j++)
                int d = nums[i] - nums[j] + 500;
                f[i][d] = f[j][d] + 1;
                ans = max(f[i][d] , ans);
            
        

        return ans + 1;
    
;

leetcode打卡——等差数列题目(LIS变式)——1218. 最长定差子序列

文章目录

• • 题目
  • 解题分析
  • 解题代码
  • • 最终解题代码

题目

解题分析

• 很明显，可以直接dp解决，这个类似于LIS的dp方式，但是这样的话时间复杂度是O(N^2)，你会发现这是会超时的！

注意与LIS的不同点：LIS是最长递增子序列，而此题是给出等差数列的公差后，求出最长等差子序列，不同之处在哪？

• 对于LIS：很明显一个是递增一个是等差，LIS的话判断标准随时在变化，具体来说就是组成这个序列的高矮参差不齐，这导致即便可能因为前面一个序列的高个子拦住，但是还能继承这个序列的矮个子，也就是离你最近的比当前数字小的元素可能不会让你直接继承得到最大长度，还需要向前继续探查。（最近的一段最长序列可能无法直接运用）
• 对于最长等差序列：而更新最长等差序列时，由于判断标准统一，也就是高矮是统一的，前面只要符合这个标准的都能直接被继续继承下来！也就是离 i 最近的 nums[j] 只要在满足 nums[i] = nums[j]+dif 后直接就能得出当前状态最长的等差数列！（最近的一段最长序列能够直接被继承）

解题代码

• 强行LIS方法

class Solution {
public:
    int longestSubsequence(vector<int>& arr, int difference) {
        int sz = arr.size();
        int dp[sz];
        fill(dp,dp+sz,1);
        for(int i=1;i<sz;i++){
            for(int j=0;j<i;j++){
                if(arr[i]-arr[j]==difference){
                    dp[i] = max(dp[i],dp[j]+1);
                }
            }
        }
        return *max_element(dp,dp+sz);
    }
};

• 根据继承标准只更新一次LIS优化

class Solution {
public:
    int longestSubsequence(vector<int>& arr, int difference) {
        int sz = arr.size();
        int dp[sz];
        fill(dp,dp+sz,1);
        for(int i=1;i<sz;i++){
            for(int j=i-1;j>=0;j--){
                if(arr[i]-arr[j]==difference){
                    dp[i] = max(dp[i],dp[j]+1);
                    break;
                }
            }
        }
        return *max_element(dp,dp+sz);
    }
};

最终解题代码

只有这个方式能过。

由于每个序列都可被直接继承，所以直接找左边的最新更新的情况即可，这下便可以通过哈希表直接记录值的关系，而不是序列的位置关系得出答案，因为我们只需要更新每个值的最新情况即可！所有运用的值也只要满足在左侧且答案是最新即可！

• 所以摒弃通过下标记录序列答案的方式！

我们现在不以数组的下标为状态进行动态规划，由于每个值都只需要更新最新状态即可，所以我们以值为状态进行动态规划，也就是具体到 dp[nums[i]] 而不是 dp[i] 。

具体转移方程如下：

dp[v] = dp[v-d] + 1

class Solution {
public:
    int longestSubsequence(vector<int>& arr, int difference) {
        int sz = arr.size();
        unordered_map<int,int>dp;
        int res = 1;
        for(int i=0;i<sz;i++){
            dp[arr[i]] = dp[arr[i]-difference]+1;
            res = max(res,dp[arr[i]]);
        }
        return res;
    }
};