最长公共子序列LCS+最长递增子序列LIS+最长递增公共子序列LICS

最长公共子序列（LCS）：两个串s1和s2中取出若干有序位置的字符，使得取出的两个字符串相同的长度的最大值就是LCS

最长递增子序列（LIS）：S的子序列，其中各元素按索引严格单调递增

最长公共递增子序列（LCIS）：上面两者的结合，参考博客：https://blog.csdn.net/wall_f/article/details/8279733

最长上升子序列的O(n^2)复杂度算法，算法的优势在于可以保存算法的转移，可以得出最后的序列。

代码如下：

#include<iostream>
using namespace std;
#define maxn 100
int n;
//  20 17 2 3 4 1 4 6 9 1 1 2 3 4 9 87 21 23 331 31 44
//   10 1 1 1 1 1 2 2 2 3 3
int a[maxn];
int dp[maxn],from[maxn];
void print (int pos)
{
    if(!pos)return;
    print(from[pos]);
    cout<<a[pos]<<' ';
}
int main()
{
    cin>>n;
    for(int i=1;i<=n;i++)cin>>a[i];
    for(int i=1;i<=n;i++)
    {
        dp[i]=1;//以i为终止位置的最长上升子序列的长度 
        for(int j=1;j<i;j++)
        {
            if(a[i]>a[j]&&dp[i]<dp[j]+1)    
            {
                dp[i]=dp[j]+1;
                from[i]=j;//使dp[i]改变的最后一个位置 
            }
        }
    }
    int ans=1,pos=1;
    for(int i=1;i<=n;i++)
    {
        if(dp[i]>ans)
        {
            ans=dp[i];//记录len改变的最后一个位置
            pos=i; 
        }
    }
    cout<<ans<<endl; 
    print(pos);
}

最长上升子序列的O(nlogn)算法， 中间结果无法保存，只能知道最长上升子序列的长度。其中加上一个辅助数组，数组的长度表示的是最长上升子序列的长度，数组中第i个位置保存的数是长度为i的最长上升子序列的末位最小元素，利用了贪心的思想，因为末尾的元素值越小的话留给下一个元素更新的余地就会更大。由于长度为n-1的最长上升子序列的末位元素一定是小于长度为n的最长上升子序列的末位元素，所以辅助数组的元素一定是有序的。

代码如下：

#include<iostream>
using namespace std;
#define maxn 100
#define INF 0x7ffffff
int n,l,r;
int a[maxn],dp[maxn];//dp[i]表示长度为i的最长上升子序列的末位元素最小值 
int main()
{
    cin>>n;
    for(int i=1;i<=n;i++)
    {
        cin>>a[i];
        dp[i]=INF;
    }
    dp[1]=a[1];
    int len=1;
     for(int i=2;i<=n;i++)
     {
         int mid;
         l=0,r=len;
         if(a[i]>dp[len])dp[++len]=a[i];
         else 
         {                              //二分查找 ，查找第一个大于a[i]的位置 
             while(l<r)
             {
                 mid=(l+r)/2;
                 if(dp[mid]>a[i])r=mid;
                 else {
                     l=mid+1;
                 }
              } 
        }
         dp[l]=min(dp[l],a[i]);
     }
     cout<<len<<endl;
 } 

最长公共子序列算法如下：（包括对路径的保存）

#include <cstdio>
#include <iostream>
using namespace std;
int dp[1000][1000];
int main()
{
    string a,b;
    while(cin>>a>>b)
    {
        for(int i=1;i<=a.size();i++)
        for(int j=1;j<=b.size();j++)
        {
           if(a[i-1]==b[j-1])dp[i][j]=dp[i-1][j-1]+1;
           else  dp[i][j]=max(dp[i-1][j],dp[i][j-1]);
        }

       char path[1000];
        for(int aa=a.size(),bb=b.size(),num=1;aa>=1&&bb>=1;)
        {
            if(a[aa-1]==b[bb-1])
            {
                path[num++]=a[aa-1];
                aa--,bb--;
            }
            else
            {
                if(dp[aa-1][bb]>dp[aa][bb-1])
                    aa--;
                else bb--;
            }
        }
        cout<<dp[a.size()][b.size()]<<endl;
        for(int i=dp[a.size()][b.size()];i>=1;i--)
            cout<<path[i]<<" ";
        cout<<endl;
    }
    return 0;
}

最长公共上升子序列算法：

#include<iostream>
#include<cstring> 
#include<string>
using namespace std;

int max(int a,int b)
{
    return a>b?a:b;
}

int a[1010],b[1010];
int f[1010],n,m;

int LCIS()
{
    int i,j,MAX;
    memset(f,0,sizeof(f));
    for(i=0;i<n;i++)
    {
        MAX=0;
        for(j=0;j<m;j++)
        {
            if(a[i]>b[j])MAX=max(MAX,f[j]);
            if(a[i]==b[j])f[j]=MAX+1; 
        }
    }
    int ans=0;
    for(i=0;i<m;i++)
        ans=max(ans,f[i]);
    return ans;
}

int main()
{
    int t,i,j;
        scanf("%d",&n);
        for(i=0;i<n;i++)
        {
            scanf("%d",&a[i]);
        }
        scanf("%d",&m);
        for(j=0;j<m;j++)
        {
            scanf("%d",&b[j]);
        }
        printf("%d
",t=LCIS());
        if(t)
            printf("
");
      for(int i=0;i<t;i++)cout<<f[t]<<endl;
    return 0;
}