动态规划-最长公共子序列

有关概念：

　　最长公共子序列(LCS,Longest Common Subsequence)，两个或者两个以上序列的所有共同子序列最长的一个（好像和没解释没什么区别）

思路：

　　对于两个序列a，b

　　f[i][j]表示a序列中1..i的部分和b序列中1...j的部分的LCS

　　那么易得，对于f[i][j]：

　　（1）如果a_i!=b_j，则从f[i-1][j]和f[i][j-1]中挑选较大的作为前驱，继承其值；

　　（2）否则，则使f[i-1][j-1]作为其前驱，继承其值并++；

　　最后输出f[lena][lenb]即可……

　　当然，可以在更新f[i][j]的时候附带更新数组记录其前驱的位置，以便最后输出

　　（我TM都讲些什么东西）

　　给出数组代码，如果是字符串的话，适当改动即可

#include<cstdio>
#define MAXN
int lena,lenb,a[MAXN],b[MAXN],ans1,ans2[MAXN];
struct node
{
    int x,nextx,nexty;
}f[MAXN][MAXN];
int main()
{
    scanf("%d",&lena);
    for(int i=1;i<=lena;++i)scanf("%d",&a[i]);
    scanf("%d",&lenb);
    for(int i=1;i<=lenb;++i)scanf("%d",&b[i]);
    for(int i=1;i<=lena;++i)
        for(int j=1;j<=lenb;++j)
        {
            if(a[i]==b[j])f[i][j]=(node){f[i-1][j-1].x+1,i-1,j-1};
            else
            {
                if(f[i-1][j].x>f[i][j-1].x)f[i][j]=(node){f[i-1][j].x,i-1,j};
                else f[i][j]=(node){f[i][j-1].x,i,j-1};
            }
        }
    printf("%d\n",f[lena][lenb].x);
    int x=lena,y=lenb;
    while(x&&y)
    {
        node temp=f[x][y];
        x=temp.nextx;y=temp.nexty;
        if(f[x][y].x==temp.x-1)ans2[++ans1]=a[x+1];
    }
    for(int i=ans1;i>=1;--i)printf("%d ",ans2[i]);
    return 0;
}