leetcode算法题--最长定差子序列

原题链接：https://leetcode-cn.com/problems/longest-arithmetic-subsequence-of-given-difference/

相关题目：最长等差数列

1、动态规划（超时）

按照最长等差数列方法

int longestSubsequence(vector<int>& arr, int difference) {
    const int offset=10001;
    int n=arr.size();
    vector<vector<int>> dp(n,vector<int>(20001,1));
    int ans=1;
    for(int j=1;j<n;j++){
        for(int i=j-1;i<j;i++){
            int dif=arr[j]-arr[i]+offset;
            if(dif!=difference+offset) continue;//添加一个判断是否等于difference
            dp[j][dif]=max(dp[j][dif],dp[i][dif]+1);
            ans=max(ans,dp[j][dif]);
        }
    }   
    return ans;
}

改进（超时）

    int longestSubsequence(vector<int>& arr, int difference) {
        const int offset=10001;
        int n=arr.size();
        vector<vector<int>> dp(n,vector<int>(20001,1));
        int ans=1;
        for(int j=1;j<n;j++){
            for(int i=j-1;i>=0;i--){//逆序遍历
                int dif=arr[j]-arr[i]+offset;
                if(dif!=difference+offset) continue;
                if(dp[j][dif]<dp[i][dif]+1){
                    dp[j][dif]=dp[i][dif]+1;
                    ans=max(ans,dp[j][dif]);
                }
                else{//若出现dp[j][dif]>+dp[i][dif]+1则退出循环
                    break;
                }             
            }
        }   
        return ans;
    }

改进：使用unordered_map存储键值到键的映射：arr[i]->i，这样可以处理有负键值的情况，但是由于会有重复的键值，于是将map<int,int>改进为map<int,vector<int>>

int longestSubsequence(vector<int>& arr, int difference) {
	int n = arr.size();
	vector<int> dp(n, 1);
	unordered_map<int, vector<int>> map;
	for (int i = 0; i<n; i++){
		map[arr[i]].push_back(i);
	}
	int ans = INT_MIN;
	for (int i = 1; i < n; i++){
		if (map.count(arr[i] - difference)){
			for (auto iter = map[arr[i] - difference].begin(); iter != map[arr[i] - difference].end(); iter++){
				int index = *iter;
				if (index < i){
					dp[i] = max(dp[i], dp[index] + 1);
				}
			}
		}
		ans = max(ans, dp[i]);
	}
	return ans;
}