最长公共子序列

如果字符串一的所有字符按其在字符串中的顺序出现在另外一个字符串二中，则字符串一称之为字符串二的子序列。注意，并不要求子序列（字符串一）的字符必须连续出现在字符串二中。请编写一个函数，输入两个字符串，求它们的最长公共子序列，并打印出最长公共子序列。
例如：输入两个字符串BDCABA和ABCBDAB，字符串BCBA和BDAB都是是它们的最长公共子序列，则输出它们的长度4，并打印任意一个子序列。

动态规划算法

事实上，最长公共子序列问题也有最优子结构性质。
记：
Xi = 即X序列的前i个字符（1<= i <= m）(前缀)
Yj = 即Y序列的前j个字符（1<= j <= m）(前缀)

假定Z = 是LCS（X,Y)中的一个。

• 若xm = yn（最后一个字符相同），则不难用反正法证明：该字符必是X与Y的任一最长公共子序列Z（设长度为k）的最后一个字符，即有zk =
  xm =
  yn，且显然有Zk-1∈LCS(Xm-1,Yn-1)，即Z的前缀Zk-1是Xm-1与Yn-1的最长公共子序列。此时，问题化归成求Xm-1与Yn-1的LCS（LCS(X,Y)）的长度等于LCS(Xm-1,Yn-1)的长度加1）。

• 若xm≠yn，则亦不难用反证法证明：要么Z∈LCS(Xm-1, Y)，要么Z∈LCS(X ,
  Yn-1)。由于zk≠xm与zk≠yn其中至少有一个必成立，若zk≠xm则有Z∈LCS(Xm-1 , Y)；类似的，若zk≠yn
  则有Z∈LCS(X , Yn-1)。此时，问题化归成求Xm-1与Y的LCS及X与Yn-1的LCS。LCS(X ,
  Y)的长度为：max{LCS(Xm-1 , Y)的长度, LCS(X , Yn-1)的长度}。

  由于上述当xm≠yn的情况中，求LCS(Xm-1 , Y)的长度与LCS(X , Yn-1)的长度，这两个问题不是相互独立的：两者都需要求LCS(Xm-1，Yn-1)的长度。另外两个序列的LCS中包含了两个序列的前缀的LCS，故问题具有最优子结构性质考虑用动态规划法。

动态规划算法解LCS问题

最长公共子序列的结构
最长公共子序列的结构有如下表示：
设序列X=和Y=的一个最长公共子序列Z=，则：
1.若 xm=yn，则 zk=xm=yn，且Zk-1是Xm-1和Yn-1的最长公共子序列；
2.若 xm≠yn且 zk≠xm ，则 Z是 Xm-1和 Y的最长公共子序列；
3.若 xm≠yn且 zk≠yn ，则 Z是 X和 Yn-1的最长公共子序列；

子问题的递归结构

由最长公共子序列问题的最优子结构性质可知，要找出Xm=和Yn=的最长公共子序列，可按如下方式递归的进行：

• 当xm = yn时，找出Xm-1和Yn-1的最长公共子序列，然后在其尾部加上xm或yn，即可得到X和Y的一个最长公共子序列；
• 当xm≠yn时，必须解两个子问题，即找出Xm-1和Y的一个最长公共子序列及X和Yn-1的一个最长公共子序列。这两个公共子序列中较长者即为X和Y的一个最长公共子序列。

可得递归关系如下所示：

计算最优值

计算最长公共子序列长度的动态规划算法LCS_Length(X,Y)，以序列X=和Y=作为输入。输出两个数组c[0..m ,0..n]和b[1..m ,1..n]。其中c[i,j]存储Xi与Yj的最长公共子序列的长度，b[i,j]记录指示c[i,j]的值是由哪一个子问题的解达到的，这在构造最长公共子序列时要用到。最后，X和Y的最长公共子序列的长度记录于c[m,n]中。

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

const int X=100,Y=100; //串的最大长度
char result[X+1]; //用于保存结果
int count=0; //用于保存公共最长公共子串的个数

/*
*   功能：计算最优值
*参数：
*        x:字符串x
*        y:字符串y
*        b:标志数组
*        xlen:字符串x的长度
*        ylen:字符串y的长度
*返回值：最长公共子序列的长度
*
*/
int Lcs_Length(string x, string y, int b[X+1][Y+1],int xlen,int ylen) 
{
    int i=0,j=0;
    int c[X+1][Y+1];
    for(i=0;i<=xlen;i++)
    {
        c[i][0]=0;
    }
    for(i=0;i<=ylen;i++)
    {
        c[0][i]=0;
    }
    for(i=1;i<=xlen;i++)
    {       
        for(j=1;j<=ylen;j++)
        {
            if(x[i-1]==y[j-1])
            {
                c[i][j]=c[i-1][j-1]+1;
                b[i][j]=1;
            }
            else
            {
                if(c[i-1][j]>c[i][j-1])
                {
                    c[i][j]=c[i-1][j];
                    b[i][j]=2;
                }
                else
                {
                    if(c[i-1][j]<c[i][j-1])
                    {
                        c[i][j]=c[i][j-1];
                        b[i][j]=3;
                    }
                    else
                    {
                        c[i][j]=c[i][j-1];
                        b[i][j]=4;
                    }
                }
            }
        }
    }
    cout<<"计算最优值效果图如下所示："<<endl;
    for(i=1;i<=xlen;i++)
    {
        for(j=1;j<ylen;j++)
        {
            cout<<c[i][j]<<" ";
        }
        cout<<endl;
    }
    return c[xlen][ylen];
}

/*
*   功能：计算最长公共子序列
*参数：
*        xlen:字符串x的长度
*        ylen:字符串y的长度
*        x    :字符串x
*        b:标志数组
*        current_len:当前长度
*        lcs_max_len:最长公共子序列长度
*
*/
void Display_Lcs(int i, int j, string x, int b[X+1][Y+1],int current_len,int lcs_max_len) 
{
    if(i==0||j==0)
    {
        for(int s=0;s<lcs_max_len;s++)
        {
            cout<<result[s];
        }
        cout<<endl;
        count++;
        return ;
    }
    if(b[i][j]==1)
    {
        current_len--;
        result[current_len]=x[i-1];
        Display_Lcs(i-1,j-1,x,b,current_len,lcs_max_len);
    }
    else
    {
        if(b[i][j]==2)
        {
            Display_Lcs(i-1,j,x,b,current_len,lcs_max_len);
        }
        else
        {
            if(b[i][j]==3)
            {
                Display_Lcs(i,j-1,x,b,current_len,lcs_max_len);
            }
            else
            {
                 Display_Lcs(i,j-1,x,b,current_len,lcs_max_len);
                 Display_Lcs(i-1,j,x,b,current_len,lcs_max_len);
            }
        }
    }
}



int main()
{
    string x,y;
    cout<<"请输入字符串1:";
    cin>>x;
    cout<<"请输入字符串2:";
    cin>>y;
    int xlen=x.length();
    int ylen=y.length();
    int b[X+1][Y+1];

    int lcs_max_len=Lcs_Length(x,y,b,xlen,ylen);
    cout <<"最长公共子序列长度为："<<lcs_max_len << endl;
    Display_Lcs(xlen,ylen,x,b,lcs_max_len,lcs_max_len);
    cout<<"共有："<<count<<"种公共子序列"<<endl;
    return 0;
}