找出数组中长度最长的等差数列

来源：互联网发布：武汉矩阵互动面试编辑：程序博客网时间：2024/05/02 01:07

T1:
http://blog.chinaunix.net/uid-26456800-id-3447973.html

求出一个有序数组中公差为d的最长等差数列。

较简单动态规划:

设等差数列的起始下标为s,当前下标为i，从s到i，构成的最长的等差数列长度为f(s,i),有

f(s,i+1) = f(s,i) +1 ( input[i+1] == input[s] + f(s,i)*d)

f(s,i) ( input[i+1] != input[s] + f(s,i)*d)

最长的数列长度为：

maxLen = max{f(s,i) s∈[1 .. max-min] i∈[0,sizeof(input)) }

算法时间复杂度应为n的平方，空间复杂度可优化至O(1) （代码中为O(n)）

http://blog.csdn.net/cwqbuptcwqbupt/article/details/7546674代码如下：

    #include <stdio.h>    #include <stdlib.h>    #define MAX 1000    void GetSeq(int *input, int size, int d){        if(input == NULL) return;        int result[MAX] = {0};                int startIndex = 0;        int maxLen = 0;        int maxLenStartIndex = -1;        for(;startIndex < size-maxLen; startIndex++){            int i = startIndex;            result[i] = 1;            i++;            for(;i<size;i++){                result[i] = result[i-1];                if(input[i] == input[startIndex] +result[i-1]*d){                    result[i]++;                    if(result[i]> maxLen){                        maxLen = result[i];                        maxLenStartIndex = startIndex;                    }                }                else if(input[i] > input[startIndex] + result[i-1]*d)                    break;            }            }        printf("Max sequence start index: %d, length: %d \n", maxLenStartIndex, maxLen);    }    int main(){        int input[] = {1,3,4,6,7,9,10,12,13,15,16,18,21,24};        GetSeq(input, sizeof(input)/sizeof(int), 3);    }

T2:

求微软面试题：求整数随机数构成的数组中找到长度大于=3的最长的等差数列

输出等差数列由小到大:

如果没有符合条件的就输出[0,0]

格式：

输入[1,3,0,5,-1,6]

输出[-1,1,3,5]

要求时间复杂度，空间复杂度尽量小

网上有动态规划的解法，时间复杂度O(N^3)：http://openuc.sinaapp.com/?p=286

而本文要提另一种动态规划解法，时间复杂度O(N^2)，空间复杂度比较大，一会说。

方法：

第一步都一样，先排序。

第二步，动态规划。在一个已排好序的数列中，等差数列的差d满足 0 <= d <= a[N-1] - a[0]。于是，设一个二维表dp，有a[N-1] - a[0] + 1 行，N列，dp[i][j]记录数列a[j]，公差为i下的最长数列长度。那么很明显有：dp[i][j] = dp[i][ index_of( a[j] + i ) ] + 1。其中index_of(num)表示数num在数组a中的索引。上述dp的意思是：如果a[j]能构成等差数列的一份子，公差为i，那么它的下一项就是a[j] + i，这当然要求a[j] + i存在于数组a中啦~而且，a[j]构成的数列的长度就是由 a[j] + i 构成数列长度加1. 依据上述分析，只要对数组a由尾到头遍历，对每个a[j]，求出所有公差从0到a[N-1]-a[0]下的最长数列长度，则问题就得解了。

注意几个问题：

1. 上述分析过程中要求求出所有公差从0到a[N-1]-a[0]，但实际上并不需要这么一个一个的求，因为以任何a[j]，它能构成等差数列，则公差一定是 a[ k ] - a[ j ]，这里 j < k < N，因此，求解的范围得到缩小，因此整体的时间复杂度为0(N^2)。

2. 另一个实现问题是，dp只记录了最长数列的长度，而我们为了能回朔并输出等差数列，我们还需要知道构成最长等差数列a[j]的下一个数是什么，因此，需要同时记录下一跳的索引。在代码中，我用pair<int,int>来记录，first记录长度，second记录下一跳索引。

3. 注意处理a[j]与多个数差值相同的情况，比如 1,3,3，对a[0]=1，它和a[1]，a[2]的差值相同，所以对于a[0]，公差为2而言，即dp[2][0]，它只需要更新一次即可。

    #include "stdafx.h"            #include <stdio.h>      #include <iostream>      using namespace std;            const int N = 10;      const int INVALID_IDX = -1;            void show(int* a,int n)      {          for (int i=0;i<n;++i)          {              cout<<a[i]<<",";          }          cout<<endl;      }            inline int compare(const void* p1,const void* p2)      {          return *(int*)p1 - *(int*)p2;      }            void longest_seq(int* a)      {          qsort(a,N,sizeof(int),&compare);                int R = a[N-1]-a[0]+1;          pair<int,int>** dp = new pair<int,int>*[R];          for (int i=0;i<R;++i)          {              pair<int,int>* row = new pair<int,int>[N];               for (int j=0;j<N;++j)              {                  row[j].first = 0;       //记录当前最长数列的长度                  row[j].second = INVALID_IDX;//记录与first相对应的等差数列的下一值在数组a中的索引              }              dp[i] = row;          }                    int maxlen = 0;          int rowidx = INVALID_IDX;          int colidx = INVALID_IDX;                for (int i=N-2;i>=0;--i)          {              for (int j=i+1;j<N;++j)              {                  if (dp[ a[j]-a[i] ][i].first != 0) continue;    //以该“差”为行号的值如果已经存在，就不需要再为相同的差值更新                                    dp[ a[j]-a[i] ][i].first = dp[ a[j]-a[i] ][j].first + 1;                  dp[ a[j]-a[i] ][i].second = j;                        if (dp[ a[j]-a[i] ][i].first > maxlen)                  {                      maxlen = dp[ a[j]-a[i] ][i].first;                      rowidx = a[j]-a[i];                      colidx = i;                  }              }          }                if( maxlen > 1 )          {              cout<<"The longest seq is:"<<endl;              while( colidx != INVALID_IDX )              {                  cout<<a[colidx]<<",";                  colidx = dp[rowidx][colidx].second;              }              cout<<endl;          }          else          {              cout<<"0,0"<<endl;          }                for (int i=0;i<R;++i)              delete []dp[i];                delete []dp;      }                  int main(void)      {          int a[N] = {8, 8, 7, 4, 1, 3, 3, 1, 8, 4};          longest_seq(a);                return 0;      }

0 0