最长上升子序列问题的几种解法

拿POJ 2533来说。

Sample Input

7
1 7 3 5 9 4 8

Sample Output

4

从输入的序列中找出最长的上升子序列（LIS）。

这题一看，是一道典型的DP问题（就是动态规划），可以用dfs,深度优先遍历来解，如下代码：

#include
#include
using namespace std;

 

int n;
int* a;
stack s;
int count=0;
int best=0;

void dfs(int i)
{
  if(i==n)
  {
    if(s.size()>best) best=s.size();
    return;
  }
  if(s.empty()||a[i]>s.top())
  {
    s.push(a[i]);
    dfs(i+1);
    s.pop();
  }
  if(s.size()+n-i-1>best) dfs(i+1);
} 

int main()
{
  while(cin>>n)

{
   int i;
  a=new int[n];
  for(i=0;i  {
    cin>>a[i];
  }
 dfs(0);
 cout< delete [] a;

}
 return 0;
}

 

其实为了简化代码以及算法效率，我们可以用数据组来代替递归。。。下面我就给出LIS的DP的数据组形式的解法：

（懒得写了，就拿个别人的代码来展示吧）

#include
#define SIZE 1001
 
using namespace std;
 
int main()
{
    int i, j, n, max;
    /* a[i]表示输入第i个元素 */
    int a[SIZE];
    /* d[i]表示以a[i]结尾的最长子序列长度 */
    int d[SIZE];
 
    while(cin >> n)
 {
  for (i = 1; i <= n; i++)
  {
   cin >> a[i];
  }
 
  max = 0;
  for (i = 1; i <= n; i++)
  {
   d[i] = 1;
   for (j = 1; j <= i - 1; j++)
   {
    if (a[j] < a[i] && d[i] < d[j] + 1) //这边，要注意 d[i] < d[j] + 1这个条件的限制，它是为了在

                                               //连续几个 d[i]相同时 只加一次
    {
     d[i] = d[j] + 1;
    }
   }
   /* 记录最长子序列 */
   if (d[i] > max) max = d[i];
  }
 
  cout << max << endl;
 }
 
    //system("pause");
    return 0;
}

（作者的解释：）令A[i]表示输入第i个元素，D[i]表示从A[1]到A[i]中以A[i]结尾的最长子序列长度。对于任意的0 <  j <= i-1，如果A(j) < A(i)，则A(i)可以接在A(j)后面形成一个以A(i)结尾的新的最长上升子序列。对于所有的 0 <  j <= i-1，我们需要找出其中的最大值。

DP状态转移方程:

D[i] = max{1, D[j] + 1} (j = 1, 2, 3, ..., i-1 且 A[j] < A[i])

解释一下这个方程，i， j在范围内:

如果 A[j] < A[i] ，则D[i] = D[j] + 1

如果 A[j] >= A[i] ，则D[i] = 1

 

其实上面的方法的复杂度都达到了O(n^2)的数量级，有没有更好的解法呢？

有，用栈。

这个解法不是我想的，从网上学来的，这里面与大家分享一下。这个算法的复杂度只有O(nlogn)，在有大量数据的情况下，这算法效率极高。。。

（摘录原作者的话）

这个算法其实已经不是DP了，有点像贪心。至于复杂度降低其实是因为这个算法里面用到了二分搜索。本来有N个数要处理是O(n)，每次计算要查找N次还是O(n)，一共就是O(n^2)；现在搜索换成了O(logn)的二分搜索，总的复杂度就变为O(nlogn)了。

这个算法的具体操作如下(by RyanWang):

开一个栈，每次取栈顶元素top和读到的元素temp做比较，如果temp > top 则将temp入栈；如果temp < top则二分查找栈中的比temp大的第1个数，并用temp替换它。 最长序列长度即为栈的大小top。

这也是很好理解的，对于x和y，如果x < y且Stack[y] < Stack[x],用Stack[x]替换Stack[y]，此时的最长序列长度没有改变但序列Q的''潜力''增大了。

举例：原序列为1，5，8，3，6，7

栈为1，5，8，此时读到3，用3替换5，得到1，3，8； 再读6，用6替换8，得到1，3，6；再读7，得到最终栈为1，3，6，7。最长递增子序列为长度4。

 

我想，当出现1，5，8，2这种情况时，栈内最后的数是1，2，8不是正确的序列啊？难道错了？

分析一下，我们可以看出，虽然有些时候这样得不到正确的序列了，但最后算出来的个数是没错的，为什么呢？

想想，当temp>top时，总个数直接加1，这肯定没错;但当temp

用该算法完成POJ2533的具体代码如下:

 

 

#include 
#define SIZE 1001
 
using namespace std;
 
int main()
{
    int i, j, n, top, temp;
    int stack[SIZE];
    while(cin >> n)
   {
    top = 0;
    /* 第一个元素可能为0 */
    stack[0] = -1;
    for (i = 0; i < n; i++)
    {
        cin >> temp;
        /* 比栈顶元素大数就入栈 */
        if (temp > stack[top])
        {
            stack[++top] = temp;
        }
        else
        {
            int low = 1, high = top;
            int mid;
            /* 二分检索栈中比temp大的第一个数 */
            while(low <= high)
            {
                mid = (low + high) / 2;
                if (temp > stack[mid])
                {
                    low = mid + 1;
                }
                else
                {
                    high = mid - 1;
                }
            }
            /* 用temp替换 */
            stack[low] = temp;
        }
    }
 
    /* 最长序列数就是栈的大小 */
    cout << top << endl;
  } 
    return 0;
}