算法题10 最长等差序列问题

题目

　　给定一个大小为n的数组，要求写出一个算法，求其最长的等差数列的子序列

分析

　　该题需要分几种情况考虑。

1. 原数组是有序的，所要求的的子序列可以不连续。

　　对于数组arr[],不同的等差值d=1,2,3,4,5```(arr[max]-arr[min])可以求出不同的最长等差数列，然后在这些等差数列中求出最长的那个即可我们首先转化为求一个数组的固定等差值的最长等差子序列。如数组1,2,4,6,8,9，求等差值2的最长等差子序列为2,4,6,8

　1.1 固定等差值的最长子序列

　　求符合条件的最长子序列可以用动态规划来做，设dis[i]记录数组arr[]的第1-i个元素子数组的最长等差子序列长度，状态转移方程式：

　　dis[i]=1;

　　dis[i]=dis[k]+1, k是数组第1-i个元素中，与元素i等差为d并且距离i最近的元素(k<i);

　 代码

int RegularArithmeticSeq(int arr[],int len,int d)
{
    if (arr==NULL||len<1)
        throw std::exception("Invalid input.");

    int* dis=new int[len+1]();

    int re_len=0,re_index=0;
    for (int i=1;i<=len;i++)
    {
        dis[i]=1;
        for (int k=i;k>0;k--)
        {                                                                                      
            int cur_d=arr[i-1]-arr[k-1];

            if (cur_d==d&&dis[i]<=dis[k])                                                                                         
            {
                dis[i]=dis[k]+1;
            }

            if (re_len<=dis[i])
            {
                re_len=dis[i];
                re_index=i;
            }

            if (cur_d>d)
                break;
        }
    }

    int out=arr[re_index-1];
    for (int n=0;n<re_len;n++)
    {
        cout<<out<<' ';
        out=out-d;
    }
    cout<<endl;

    delete[] dis;

    return re_len;
}

　　上述代码的时间复杂度为O(n*n),时间复杂度为O(n);

　　对于寻找1-i中最后一个和i等差的元素k,除了顺序遍历，还可以用二分查找法进行一点优化，查找的时间复杂度为O(logn)

int find_k(int arr[],int n,int d)
{
    int small=0,big=n-1,k=0,sum=0;
    while (small<=big)
    {
        k=small+(big-small)/2;
        sum=arr[k]+d;
        if (sum<arr[n-1])
        {
            small=k+1;
        }else if(sum>arr[n-1])
        {
            big=k-1; 
        }else
        {
            if (k<=big&&(arr[k+1]+d)!=sum)
            {
                return k;
            }else
            {
                small=k+1;
            }
        }
    }

    return n-1;
}

　优化代码

int RegularArithmeticSeq2(int arr[],int len,int d,int& re_idx)
{
    if (arr==NULL||len<1)
        throw std::exception("Invalid input.");

    int* dis=new int[len]();

    int* dif=new int[len](); 
    for (int i=0;i<len;i++)
    {
        dif[i]=find_k(arr,i+1,d);
    }

    int re_len=0,re_index=0;
    for (int i=0;i<len;i++)
    {
        dis[i]=1;
        if (dif[i]!=i)
        {
            dis[i]=dis[dif[i]]+1;
        }
        if (re_len<=dis[i])
        {
            re_len=dis[i];
            re_index=i;
        }
    }

    int out=arr[re_index];
    re_idx=re_index+1;
    for (int n=0;n<re_len;n++)
    {
        cout<<out<<' ';
        out=out-d;
    }
    cout<<endl;

    delete[] dis;
    delete[] dif;

    return re_len;
}

　　上述过程中时间复杂度降为O(n*logn)

　1.2 非固定等差值的最长子序列　　

　　在解决了固定等差值得最长子序列后，就可以着手求非固定等差值的最长子序列了。等差值d的范围是1,2···(arr[max]-arr[min])，循环着m个等差值，然后求出最长的等差子序列即可

　　时间复杂度(n*logn*m),m<=n-1;空间复杂度O(n*m)

　　代码　

int ArithmeticSeq(int arr[],int len)
{
    if (arr==NULL||len<1)
        throw std::exception("Invalid input.");

    int max_d=arr[len-1]-arr[0];
    int re_len=0,re_d=0,re_index=0;

    for (int d=1;d<=max_d;d++)
    {
        int idx=0;
        int dlen=RegularArithmeticSeq2(arr,len,d,idx);
        if(re_len<=dlen)
        {
            re_len=dlen;
            re_d=d;
            re_index=idx;
        }
    }

    int out=arr[re_index-1];
    for (int n=0;n<re_len;n++)
    {
        cout<<out<<' ';
        out=out-re_d;
    }
    cout<<endl;

    return re_len;
}

　　也有另外一种解法：设dis[i][d]为数组中第1到i个元素中等差值为d的最长子序列的长度（序列可以不连续），则动态规划式;

　　dis[i][d]=1,默认等1，即在1-i个元素中等差值为d的最长子序列长度至少是1（i元素本身）

　　dis[i][d]=dis[k][d]+1, k为1-i个元素中最后一个与i元素的等差d的元素

　　代码

int ArithmeticSeq(int arr[],int len)
{
    if (arr==NULL||len<1)
        throw std::exception("Invalid input.");

    int max_d=arr[len-1]-arr[0];
    int** dis=new int*[len+1];
    for (int i=0;i<=len;i++)
    {
        dis[i]=new int[max_d+1]();
        dis[i][0]=1;
    }

    int re_len=0,re_d=0,re_index=0;
    for (int i=1;i<=len;i++)
    {
        for (int d=1;d<=max_d;d++)
        {
            dis[i][d]=1;
            for (int k=1;k<i;k++)
            {                                                                                      
                int cur_d=arr[i-1]-arr[k-1];
                if (cur_d==d&&dis[i][d]<=dis[k][d])                                                                                         
                {
                    dis[i][d]=dis[k][d]+1;
                }
                                                                                               
                if (re_len<=dis[i][d])
                {
                    re_len=dis[i][d];
                    re_d=d;
                    re_index=i;
                }
            }

        }
    }

    int out=arr[re_index-1];
    for (int n=0;n<re_len;n++)
    {
        cout<<out<<' ';
        out=out-re_d;
    }
    cout<<endl;

    for (int i=0;i<=len;i++)
    {
        delete[] dis[i];
    }
    delete[] dis;

    return re_len;
}

2. 原数组是无序的，所要求的的子序列可以不连续。

　　网上有不用排序的解法，但笔者觉得先排序还是更好些，也容易理解。当然，解此题的关键是找到在循环i和d的过程中找到k,对于非排序数组用顺序查找k,也可以。

　　代码略

3. 原数组是无序的，所要求的的子序列连续。

int ArithmeticSeq3(int arr[],int len)
{
    if (arr==NULL||len<1)
        throw std::exception("Invalid input.");

    int re_len=1,d=1;
    int max_len=0,re_d=0,re_index=0;
    for (int i=1;i<len;i++)
    {
        if((arr[i]-arr[i-1])==d)
        {
            re_len=re_len+1;
        }else
        {
            re_len=2;            
        }
        d=arr[i]-arr[i-1];
        if (max_len<=re_len)
        {
            max_len=re_len;
            re_d=d;
            re_index=i;
        }
    }

    int out=arr[re_index];
    for (int n=0;n<max_len;n++)
    {
        cout<<out<<' ';
        out=out-re_d;
    }                                                                         
    cout<<endl;

    return re_len;
}