问题描述

最长递增子序列也称 “最长上升子序列”，简称LIS ( longest increasing subsequence)。设L=<a1,a2,…,an>是n个不同的实数的序列，L的递增子序列是这样一个子序列Lis=<ak1,ak2,…,akm>，其中k1<k2<…<km且ak1<ak2<…<akm。求最大的m值。

如：求一个一维数组arr[i]中的最长递增子序列的长度，如在序列{ 7, 1, 6, 5, 3, 4, 8 }中，最长递增子序列长度为4，其递增子序列为：1，3，4，8。

问题解决

对于这类问题比较直观的想法是用动态规划，就像最长公共子序列(LCS)求解方法一样，对于动态规划问题，往往存在递推解决方法,需要首先建立递推关系。

方法1，DP求解

定义dp[i] : dp[i]为以arr[i]结尾的最长递增子序列的长度。对于第i个元素其递增序列长度最小值为1 即其自身。对于以arr[i]结尾的递增序列，分两组情况：

A，只包含arr[i]的子序列； B, 对于满足 j<i 且arr[i] > arr[j] 的以arr[j] 为结尾的递增子序列，然后追加上arr[i]得到的子序列；

对应的递推关系为：

dp[i] = max{1,dp[j]+1 | j<i 且 arr[j]<arr[i]}

使用这一递推公式即可完成LIS求解问题，代码如下：

#include <cstdio>
#include <algorithm>

const int MAX=16;

int dp[MAX];
//DP
//dp[i]表示以arr[i]为末尾的最长上升子序列的长度
int solve_lis_1(int *arr, int n)
{
    if(!arr || n<1)
        return -1;
    int res=0;
    for(int i=0; i<n; i++)
    {
        dp[i]=1;
        for(int j=0; j<i; j++)
        {
            if(arr[j]<arr[i])
                dp[i]=std::max(dp[i], dp[j]+1);
        }
         res=std::max(res, dp[i]);
    }
    return res;
}
int main()
{
    int a[]={7,1,5,3,4};
    printf("LIS:%d\n", solve_lis_1(a, sizeof(a)/sizeof(int)));
    return 0;
}

方法2，DP+二分搜索

我们期望在前i个元素中的所有长度为len的递增子序列中找到这样一个序列，它的最大元素比arr[i+1]小，而且长度要尽量的长，如此，我们只需记录len长度的递增子序列中最大元素的最小值就能使得将来的递增子序列尽量地长。

维护一个数组dp[i]，记录所有长度为i+1的递增子序列中末尾元素的最小值，并对于数组中的每个元素考察其是那个子序列的末尾元素，二分更新dp数组，最终i的值便是最长递增子序列的长度。总的说来就是，dp[i] 表示长度为i+1的上升子序列中末尾元素的最小值.

最开始全部dp[i]的值初始化为无穷大 INF，然后由前向后逐个考虑序列的元素，对于某个aj ,如果i=0或者dp[i-1] < aj, 就用dp[i]=min(dp[i], aj)进行更新。最终找出

dp[i]<INF的最大i+1就是答案了。

代码如下：

/*
 Problem:DP LIS,动态规划求解最长递增子序列
 Mem:挑战程序设计 P64
*/
#include <cstdio>
#include <algorithm>

const int MAX=16;

int dp[MAX];
//DP
//dp[i]表示以arr[i]为末尾的最长上升子序列的长度
int solve_lis_1(int *arr, int n)
{
    if(!arr || n<1)
        return -1;
    int res=0;
    for(int i=0; i<n; i++)
    {
        dp[i]=1;
        for(int j=0; j<i; j++)
        {
            if(arr[j]<arr[i])
                dp[i]=std::max(dp[i], dp[j]+1);
        }
         res=std::max(res, dp[i]);
    }
    return res;
}

// DP + 二分搜索
//dp[i] 表示长度为i+1的上升子序列中末尾元素的最小值
int solve_lis_2(int *arr, int n)
{
    const int INF=0xffffff;
    int i;
    for(i=0; i<n; i++)// 初始化dp[i]为 INF
        dp[i]= INF;
    for(i=0; i<n; i++)
    {
        *std::lower_bound(dp, dp+n, arr[i]) = arr[i];
    }
    return std::lower_bound(dp, dp+n, INF)-dp;
}

int main()
{
    int a[]={7,1,5,3,4};
    printf("LIS:%d\n", solve_lis_1(a, sizeof(a)/sizeof(int)));
    printf("LIS:%d\n", solve_lis_2(a, sizeof(a)/sizeof(int)));
    return 0;
}

其中二分查找算法是利用STL的lower_bound 函数 这个函数在有序序列中利用二分搜索技术找到指向满足 ai>=k的ai最小指针,参见这里。

对于序列{7,1,5,3,4} 方法 solve_lis_2 dp数组变化如图所示。

方法2的时间度为：因为二分查找的复杂度为O(logn) 加上外层循环，总体复杂度为 O(nlogn)。

参考:

http://www.ahathinking.com/archives/117.html