【动态规划】最长公共子序列问题

题目&&问题分析

给定两个序列X={x1,x2,…,xm}和Y={y1,y2,…,yn},求X和Y的一个最长公共子序列。

算法

动态规划 vs分治

分治是将一个问题分解为若干个规模差不多的子问题，然后分别求解，最后把各个问题的解合并得到最终解。动态规划也是将问题分解，但是不同之处在于动态规划是先求最小子问题的解，然后在求解较大子问题的时候可以直接用之前的结果。举个栗子可能会好理解一点，比如你想造一辆车，分治呢就是有了图纸，然后对着图纸找需要的零件，最后把零件拼起来就好啦。而动态规划呢，是先把可能用到的零件找全了，然后开始造车，需要什么零件直接取就可以。

算法核心

（这部分有参考《趣学算法》，当然也有很多自己的理解和想法，如有bug，欢迎批评指正）
这个问题采用动态规划，就是先求解出两个子序列到每一位的子序列的最长公共子序列的长度，就是求{x1}和{y1},{y1,y2},{y1,y2,…}，{x1,x2}和{y1},{y1,y2},{y1,y2,…}…以此类推直到求到X和Y的最长公共子序列。
c[][]:c[i][j]存放的是a[:i]和b[:j]的最长子序列的长度；
a,b:两个待求解序列；
s:a和b的最长公共子序列；
sk:s的最后一位;
s’:s去掉最后一位所得序列；
其中求解子问题也就是求子序列的最长子序列的长度最重要的就是递推公式：
if a[i-1]==b[j-1],c[i][j]=c[i-1][j-1]+1;
if a[i-1]!=b[i-1],c[i][j]=max(c[i][j-1],c[i-1][j]);
以上两个公式均可由反证法得出，
（1）s为a和b的最长公共子序列，当a和b最后一位相同且等于sk的时候，假设s’不是a（m-1）和b(n-1)的最长公共子序列,那么一定存在一个长度大于|s’|的序列t’为这两个子序列的最长公共子序列，又因为最后一位相同，那么t’+{sk}就是a和b的最长公共子序列，可知它的长度一定大于s,那么t’+{sk}即为a和b的最长公共子序列，与s是a和b的最长公共子序列矛盾。可得s’为a(m-1)和b(n-1)的最长公共子序列，所以c[i][j]=c[i-1][j-1]+1;
（2）s为a和b的最长公共子序列，当a和b的最后一位不同且a的最后一位与sk相同时，假设s不是a和b（n-1）的最长公共子序列，那么一定存在长度大于|s|的序列t为这两个序列的最长公共子序列，因为b(n-1)加上b的最后一位不会影响最长公共子序列，所以t也是a和b的最长公共子序列，这与s为a和b的最长公共子序列矛盾，所以假设不成立。同理可证当a和b的最后一位不同且b的最后一位与sk相同时，s是a(m-1)和b的最长公共子序列。可得c[i][j]=max(c[i-1][j],c[j-1][i])。

算法流程

首先呢需要一个求解子问题也就是各个子序列的最长公共子序列长度的数组c[][],还有记录c[i][j]计算方法的数组d[][],以便之后得到最长公共子序列。先把这两个数组的第一行和第一列初始化为0，然后用双重循环求c[][],同时用d[][]记录c[][]的计算方法：1表示c[i-1][j-1]+1,2表示c[i][j]=c[i][j-1],3表示c[i][j]=c[i-1][j]。之后用output(int i,int j)通过b[i][j]的值得到c[i][j]的来源，如果b[i][j]==1,就调用output(i-1,j-1),然后输出a[i-1] (或者是b[j-1]); 如果b[i][j]==2,就调用output(i,j-1);如果b[i][j]==3,就调用output(i-1,j),这样即可得到最长公共子序列了。

代码实现

#include<iostream>
using namespace std;
const int maxn=105;

int c[maxn][maxn];//c[i][j]记录的是a[:i]和b[:j]的最长公共子序列的长度
int d[maxn][maxn];//最长公共子序列的来源，以便最后得到最长公共子序列
string a,b;//存放两个待比较序列

void LongestSubstr()
{
    int m=a.size(),n=b.size();//两个序列的长度
    int i,j;
    for(i=0; i<=m; ++i)//将第一行和第一列初始化为0
    {
        c[i][0]=0;
        d[i][0]=0;
    }
    for(j=0; j<=n; ++j)
    {
        c[0][j]=0;
        d[0][j]=0;
    }
    for(i=1; i<=m; ++i)
        for(j=1; j<=n; ++j)
        {
            if(a[i-1]==b[j-1])
            {
                c[i][j]=c[i-1][j-1]+1;
                d[i][j]=1;//表示最长子序列长度由左上角一位加1得到
            }
            else//当字符不相同的时候
            {
                if(c[i][j-1]>c[i-1][j])//左侧大于上侧
                {
                    c[i][j]=c[i][j-1];
                    d[i][j]=2;//表示从左侧而来
                }
                else//上侧大于左侧
                {
                    c[i][j]=c[i-1][j];
                    d[i][j]=3;//表示从上侧而来
                }
            }
        }
}

void output(int i,int j)
{
          if(i==0||j==0)
                    return ;
          if(d[i][j]==1)
          {
                    output(i-1,j-1);
                    cout<<a[i-1];
          }
          else if(d[i][j]==2)
                    output(i,j-1);
          else
                    output(i-1,j);
}

int main()
{
    cout<<"请输入第一个序列:";
    cin>>a;
    cout<<"请输入第二个序列:";
    cin>>b;
    LongestSubstr();
    //cout<<c[a.size()][b.size()]<<endl;
    output(a.size(),b.size());
    return 0;
}

一点想法

其实还可以不用d[][]数组来记录来源，直接在输出函数中判断c[i][j]的来源也可以。刚开始我是直接写的数值判断，但是这种方法是错误的，就像下面这样：

#include<iostream>
using namespace std;
const int maxn=105;

int c[maxn][maxn];//c[i][j]记录的是a[:i]和b[:j]的最长公共子序列的长度
//int d[maxn][maxn];//最长公共子序列的来源，以便最后得到最长公共子序列
string a,b;//存放两个待比较序列

void LongestSubstr()
{
    int m=a.size(),n=b.size();//两个序列的长度
    int i,j;
    for(i=0; i<=m; ++i)//将第一行和第一列初始化为0
    {
        c[i][0]=0;
        //d[i][0]=0;
    }
    for(j=0; j<=n; ++j)
    {
        c[0][j]=0;
        //d[0][j]=0;
    }
    for(i=1; i<=m; ++i)
        for(j=1; j<=n; ++j)
        {
            if(a[i-1]==b[j-1])
            {
                c[i][j]=c[i-1][j-1]+1;
                //d[i][j]=1;//表示最长子序列长度由左上角一位加1得到
            }
            else//当字符不相同的时候
            {
                if(c[i][j-1]>c[i-1][j])//左侧大于上侧
                {
                    c[i][j]=c[i][j-1];
                    //d[i][j]=2;//表示从左侧而来
                }
                else//上侧大于左侧
                {
                    c[i][j]=c[i-1][j];
                    //d[i][j]=3;//表示从上侧而来
                }
            }
        }
        for(i=1;i<=m;++i)
        {
                  for(j=1;j<=n;++j)
                    cout<<c[i][j]<<" ";
                  cout<<endl;
        }
}

void output(int i,int j)//WA写法!!!
{
          if(i==0||j==0)
                    return ;
          if(c[i][j]==c[i-1][j-1]+1)//只是数值相等不不能保证一定是从左上角而来
          {
                    output(i-1,j-1);
                    cout<<a[i-1];
          }
          else if(c[i][j]==c[i][j-1])
                    output(i,j-1);
          else
                    output(i-1,j);
}

int main()
{
    cout<<"请输入第一个序列:";
    cin>>a;
    cout<<"请输入第二个序列:";
    cin>>b;
    LongestSubstr();
    //cout<<c[a.size()][b.size()]<<endl;
    output(a.size(),b.size());
    return 0;
}

这种方法为什么错误呢，是因为可能会出现c[i][j]=c[i][j-1]或者是c[i-1][j]而且又有c[i][j]==c[i-1][j-1]+1的情况，在这种情况下，先判断c[i][j]和c[i-1][j-1]+1是否相等，相等之后进入第一个分支，但是是应该进入第二个或者是第三个分支的，所以会出现错误。举个栗子可能会好理解一点：
a:asd;
b:as;
c[][]:
c 0 1 2
0 0 0 0
1 0 1 1
2 0 1 2
3 0 1 2
我们可以看到c[3][2]==c[2][1]+1,但是其实c[3][2]的来源是c[2][2],直观的错误就是不应该输入a[2]也就是d,但是却输出了，就是因为判断的时候由于数值巧合地相等所以进入了第一个分支，导致了输出错误。要解决这个问题，可以直接用循环中决定c[i][j]来源的方法，如下所示：

void output(int i,int j)
{
          if(i==0||j==0)
                    return ;
          if(a[i-1]==b[j-1])//从左上角而来
          {
                    output(i-1,j-1);
                    cout<<a[i-1];
          }
          else if(c[i][j-1]>c[i-1][j])//从上侧而来
                    output(i,j-1);
          else
                    output(i-1,j);
}