求最长等差数列长度

Longest Consecutive Sequence

https://leetcode.com/problems/longest-consecutive-sequence/

LeetCode上面这道题是求最长连续子序列。换种说法就是求公差为1的最长等差数列。

题目描述

Given an unsorted array of integers, find the length of the longest consecutive elements sequence.

For example,
Given [100, 4, 200, 1, 3, 2],
The longest consecutive elements sequence is [1, 2, 3, 4]. Return its length: 4.

Your algorithm should run in O(n) complexity.

分析：

需要注意的是时间复杂度要求是O(n)，所以排序后再处理那种方法是不可行的。我们可以就用数组中的元素作为key建立hash表，然后直接循环遍历找当前元素val的，val-1，val+1。

代码：

class Solution {
public:
    int longestConsecutive(vector<int>& nums) {
        int n=nums.size();
        if(n==0 || n==1){
            return n;
        }
        int longest=1,val,cur;
        unordered_map<int,int> m;
        for(int i=0;i0;//没有被访问过的标记为0
        }
        for(int i=0;iif(m[nums[i]]){
                continue;
            }
            cur=1;
            val=nums[i]-1;
            while(m.find(val)!=m.end() && !m[val]){
                m[val]=1;
                val--;
                cur++;
            }
            val=nums[i]+1;
            while(m.find(val)!=m.end() && !m[val]){
                m[val]=1;
                val++;
                cur++;
            }
            longest=max(longest,cur);
        }
        return longest;
    } 
};

题目：

给一个无序数组，求这个数组中元素所能形成的最长等差数列的长度。

分析：

这里的公差d就未知了。两种dp方法。

第一种：
dp[i][d]表示数组0~i范围内，公差为d的等差数列长度。
dp[i][d]=dp[j][d]+1。
其实跟插入排序法有点像，范围由小往大扩展，当范围i定了之后，再倒着从j=i-1到j=0，我们对(i,j)形成的每个公差d=nums[i]-nums[j]所构成的dp[i][d]进行处理。

第二种：
dp[i][j]表示以nums[i]作为首项,nums[j]作为第二项的等差数列长度。
所以，我们需要从后往前进行处理。
由等差数列的性质我们可知，如果nums[i]，nums[j]，nums[k]构成等差数列，则满足nums[i]+nums[k]=2nums[j]。
初始化工作对于dp[0..n-2][n-1]=2。
j从n-2开始，从后往前找满足条件nums[i]+nums[k]=2nums[j]的元素，如果满足则dp[i][j]=dp[j][k]+1。

代码：

第一种：

int LongestArithmeticSequence(vector<int> nums){
    int n = nums.size();
    sort(nums.begin(),nums.end());
    int len = nums[n - 1] - nums[0];
    vector<vector<int>> dp(n,vector<int>(len+1,1));//dp[i][d]表示0~i范围内，公差为d的等差数列长度
    int d,longest=1;//公差
    for (int i = 1; i < n; i++){
        for (int j = i - 1; j >= 0; j--){
            d = nums[i] - nums[j];
            dp[i][d] = dp[j][d]+1;
            longest = max(longest,dp[i][d]);
        }
    }
    return longest;
}

第二种：

int LongestArithmeticSequence(vector<int> nums){
    int n = nums.size();
    sort(nums.begin(),nums.end());
    vector<vector<int>> dp(n, vector<int>(n));
    {
        for (int i = 0; i < n - 1; i++){
            dp[i][n - 1] = 2;
        }
    }
    int i, k,longest=1;
    for (int j = n - 2; j >= 0; j--){
        i = j - 1;
        k = j + 1;
        while (i >= 0 && k < n){
            if (nums[i] + nums[k] == 2 * nums[j]){
                dp[i][j] = dp[j][k] + 1;
                longest = max(longest,dp[i][j]);
                i--;
                k++;
            }
            else if (nums[i] + nums[k]>2 * nums[j]){
                i--;
            }
            else{
                k++;
            }
        }
    }
    return longest;
}