Longest Increasing Subsequence

   传统上解决longest incresing subsequence 的算法的时间复杂度是O(n^2) ，算法如下：

int  lcs(  int *  a,  int  N ) {
    int   * best,  * prev, i, j, max  =   0 ;
   best  =  ( int * ) malloc (  sizeof (  int  )  *  N );
   prev  =  ( int * ) malloc (  sizeof (  int  )  *  N );
 
    for  ( i  =   0 ; i  <  N; i ++  ) best[i]  =   1 , prev[i]  =  i;
 
    for  ( i  =   1 ; i  <  N; i ++  )
       for  ( j  =   0 ; j  <  i; j ++  )
          if  ( a[i]  >  a[j]  &&  best[i]  <  best[j]  +   1  )
            best[i]  =  best[j]  +   1 , prev[i]  =  j;   //  prev[] is for backtracking the subsequence
 
    for  ( i  =   0 ; i  <  N; i ++  )
       if  ( max  <  best[i] )
         max  =  best[i];
 
   free( best );
   free( prev );
 
    return  max;
}
 
//  Sample usage.
int  main(){
   int  b[]  =  {  1 ,  3 ,  2 ,  4 ,  3 ,  5 ,  4 ,  6  };
   //  the longest increasing subsequence = 13456?
   //  the length would be 5, as well lcs(b,8) will return.
  printf( " %d " , lcs( b,  8  ) );
}

    由于只是找上升的子序列，因此可以进一步优化，优化算法的思想这样 (http://www.mydrs.org/program/list-id=583.htm)：先回顾经典的O(n^2)的动态规划算法，设A[i]表示序列中的第i个数，F[i]表示从1到i这一段中以i结尾的最长上升子序列的长度，初始时设F[i] = 0(i = 1, 2, ..., len(A))。则有动态规划方程：F[i] = max{1, F[j] + 1} (j = 1, 2, ..., i - 1, 且A[j] < A[i])。

　　现在，我们仔细考虑计算F[i]时的情况。假设有两个元素A[x]和A[y]，满足

　　　(1)x < y < i (2)A[x] < A[y] < A[i] (3)F[x] = F[y]

　　此时，选择F[x]和选择F[y]都可以得到同样的F[i]值，那么，在最长上升子序列的这个位置中，应该选择A[x]还是应该选择A[y]呢？

　　很明显，选择A[x]比选择A[y]要好。因为由于条件(2)，在A[x+1] ... A[i-1]这一段中，如果存在A[z]，A[x] < A[z] < a[y]，则与选择A[y]相比，将会得到更长的上升子序列。

　　再根据条件(3)，我们会得到一个启示：根据F[]的值进行分类。对于F[]的每一个取值k，我们只需要保留满足F[i] = k的所有A[i]中的最小值。设D[k]记录这个值，即D[k] = min{A[i]} (F[i] = k)。

　　注意到D[]的两个特点：

　　(1)　D[k]的值是在整个计算过程中是单调不上升的。
　　(2)　D[]的值是有序的，即D[1] < D[2] < D[3] < ... < D[n]。

　　利用D[]，我们可以得到另外一种计算最长上升子序列长度的方法。设当前已经求出的最长上升子序列长度为len。先判断A[i]与D[len]。若A[i] > D[len]，则将A[i]接在D[len]后将得到一个更长的上升子序列，len = len + 1， D[len] = A[i]；否则，在D[1]..D[len]中，找到最大的j，满足D[j] < A[i]。令k = j + 1，则有D[j] < A[i] <= D[k]，将A[i]接在D[j]后将得到一个更长的上升子序列，同时更新D[k] = A[i]。最后，len即为所要求的最长上升子序列的长度。

　　在上述算法中，若使用朴素的顺序查找在D[1]..D[len]查找，由于共有O(n)个元素需要计算，每次计算时的复杂度是O(n)，则整个算法的时间复杂度为O(n^2)，与原来的算法相比没有任何进步。但是由于D[]的特点(2)，我们在D[]中查找时，可以使用二分查找高效地完成，则整个算法的时间复杂度下降为O(nlogn)，有了非常显著的提高。需要注意的是，D[]在算法结束后记录的并不是一个符合题意的最长上升子序列！

　　这个算法还可以扩展到整个最长子序列系列问题，整个算法的难点在于二分查找的设计，需要非常小心注意。   这种优化的算法的时间复杂度为O(nlog(n)) ，算法例子为： (http://www.algorithmist.com/index.php/Longest_Increasing_Subsequence.cpp)

#include  < vector >
using   namespace  std;
 
/*  Finds longest strictly increasing subsequence. O(n log k) algorithm.  */
template < typename T >  vector < int >  find_lis(vector < T >   & a)
{
    vector < int >  b, p(a.size());
     int  u, v;
 
     if  (a.size()  <   1 )  return  b;
 
    b.push_back( 0 );
 
     for  ( int  i  =   1 ; i  <  ( int )a.size(); i ++ ) {
         if  (a[b.back()]  <  a[i]) {
            p[i]  =  b.back();
            b.push_back(i);
             continue ;
        }
 
         for  (u  =   0 , v  =  b.size() - 1 ; u  <  v;) {
             int  c  =  (u  +  v)  /   2 ;
             if  (a[b[c]]  <  a[i]) u = c + 1 ;  else  v = c;
        }
 
         if  (a[i]  <  a[b[u]]) {
             if  (u  >   0 ) p[i]  =  b[u - 1 ];
            b[u]  =  i;
        }    
    }
 
     for  (u  =  b.size(), v  =  b.back(); u -- ; v  =  p[v]) b[u]  =  v;
     return  b;
}
 
/*  Example of usage:  */
#include  < cstdio >
int  main()
{
     int  a[]  =  {  1 ,  9 ,  3 ,  8 ,  11 ,  4 ,  5 ,  6 ,  4 ,  19 ,  7 ,  1 ,  7  };
    vector < int >  seq(a, a + sizeof (a) / sizeof (a[ 0 ]));
    vector < int >  lis  =  find_lis(seq);
 
     for  (unsigned i  =   0 ; i  <  lis.size(); i ++ )
        printf(i + 1   <  lis.size()  ?   " %d  "  :  " %d " , seq[lis[i]]);
 
     return   0 ;
}