动态规划之最长递增子序列LIS

子序列： 一个序列 S: { n1 n2 n3 ... ni },任意删除若干项，剩余的序列叫做S的一个子序列。

也可以认为是从序列S按原顺序保留任意若干项得到的序列。现在我们要求解一个数组里最长递增子序列的长度。在此我提出两种方法，并且附上代码。

解决方法：

（1）利用动态规划求解两个数组的最长哦公共子序列来求解这种题目，但只适用于求解最长递增子序列的长度。

思想：

输入数组a[ ],把a[ ]原封不动地保存在b[ ]里，然后对b[ ]进行递增排序，并且如果有相等的元素，只保留一个，然后得到c[ ],最后对a[ ]和c[ ]进行最长递增子序列的动态规划，求出其长度。

关于动态规划求解两数组最长公共子序列的问题，博主已经在另一片文章中介绍过：

附上链接地址：https://blog.youkuaiyun.com/Zheng_Ze_qi/article/details/79846531

附上代码：

#include<iostream>
#include<cstring>
#include<cstdio>
#include<algorithm>
using namespace std;
int n;
int a[1002],b[1002],c[1002];
int dp[1001][1001];
int i, k, j, sum;

int cmp(int a, int b)
{
    return a<b;
}
int main()
{
    while(scanf("%d",&n)!=EOF&&n)
    {
        for(i=0;i<n;i++)
        {
            scanf("%d",&a[i]);
            b[i]=a[i];
        }

        sort(b,b+n,cmp);   //对b[]进行递增排序

        c[0]=b[0];
        k=0;
        for(i=1;i<n;i++)   //对b[]进行扫描，发现相同的元素则只保留一个，结果存储在c[]里
        {
            if(c[k]==b[i])
                continue;
            else c[++k]=b[i];
        }

        k++;     //因为c[]是从0开始存储的，所以再加1才是c[]的长度
        sum=0;
        for(i=0;i<=n;i++)
            dp[i][0]=0;
        for(j=0;j<=k;j++)
            dp[0][j]=0;
         //动态规划求解最长公共子序列
        for(i=1;i<=n;i++){
            for(j=1;j<=k;j++){
                if(a[i-1]==c[j-1]){//字符数组从0开始存数据的
                    //当a[]和c[]的最后一个字符相同时，dp(i,j)=dp(i-1,j-1)+1;
                    dp[i][j]=dp[i-1][j-1]+1;
                }
                else{
                    //当a[]和c[]的最后一个字符不同时，dp(i,j) = Max(dp(i,j-1),dp(i-1,j) );
                    dp[i][j]=max(dp[i][j-1],dp[i-1][j]);
                }
            }
        }
    cout<<dp[n][k]<<endl;;
    memset(dp,0,sizeof(dp));
    }
    return 0;
}

运行结果：

（2）

一个序列有n个数：a[1],a[2],…,a[n]，求出最长递增子序列的长度。

记dp[ i ]为检索到数组a[ i ]时最长递增子序列的最长值。初始化dp[ i ]都为1.

d[ i ] = max( dp[i], max{ dp[ j ] } + 1 ), 其中，j要小于i，并且a[ j ]要小于a[ i ]。

比如说对于测试数据3 1 4 1 5 9来说：

• 第一个数字3，d[1] = 1
• 第二个数字1，前面没有比他还小的了，d[2] = 1
• 第三个数字4，最长的递增子序列就是3，4，或者1,4，d[3] = max( dp[4],dp[2]+1 )
• 第四个数组1，d[4] = max( dp[4],max{ dp[ j ] } + 1 ), 其中，j要小于4，并且a[ j ]要小于a[ 4 ]。
  在这里显然max{ dp[ j ] } = 2,因为dp[3]=2,但是a[3]=4>a[4]=1,所以dp[4]=max( 1, 2 )=2
• 第五个数字5，d[5] = max( dp[5],max{ dp[ j ] } + 1 ), 其中，j 要小于5，并且a[ j ]要小于a[ 5 ]。
  在这里显然max{ dp[ j ] } = 2,因为dp[3]=2,并且a[3]=4<a[5]=5,所以dp[5]=max( 1, 2+1 )=3
  
• 第六个数字9，d[6] = max( dp[6],max{ dp[ j ] } + 1 ), 其中，j 要小于6，并且a[ j ]要小于a[ 6 ]。
  在这里显然max{ dp[ j ] } = 3,因为dp[5]=5,并且a[5]=5<a[6]=9,所以dp[6]=max( 1, 3+1 )=4
  附上代码：
  
  

#include<iostream>
#include<algorithm>
#include<cstdio>
#include<cstring>
using namespace std;

int n, i, j;
int a[1001], b[1001], dp[1001];

int main()
{
    while(scanf("%d",&n)!=EOF)
    {
        for(i=1;i<=n;i++)
            scanf("%d",&a[i]);

        memset(dp,0,sizeof(dp));

        for(i=1;i<=n;i++)
        {
            dp[i]=1;
            for(j=1;j<i;j++)
                if(a[j]<a[i])
                    dp[i]=max(dp[j]+1,dp[i]);
        }

        cout<<dp[n]<<endl;
    }
    return 0;
}

运行结果：