算法題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;
}