Longest Increasing Subsequence-CSDN博客

传统上解决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 ;
}