LCS (Longest Common Subsequence)(连续+不连续两种情况)

关于最长公共子序列：

LCS是两个序列相似性的一种度量方法；

若序列s1：2,5,7,9,3,1,2

         s2：3,5,3,2,8

则LCS为：5,3,2

思路可参考：http://www.csie.ntnu.edu.tw/~u91029/LongestCommonSubsequence.html

具体代码实现为：

#include<iostream>
using namespace std;

int s1[7+1]={0,2,5,7,9,3,1,2};
int s2[7+1]={0,3,5,3,2,8};
const int s1_length=8;
const int s2_length=6;
const int LEFT=1;
const int UP=2;
const int UP_LEFT=3;
const int LEFTORUP=4;

int arr[7+1][5+1]={0};
int pre[7+1][5+1]={0};

void LCS();
void print_LCS(int i,int j);

int main()
{
    cout<<"the LCS of the sequence is:";
    LCS();
    return 0;
}

void LCS()
{
    for(int i=0;i<s2_length;++i)
        arr[0][i]=0;
    for(int i=0;i<s1_length;++i)
        arr[i][0]=0;

    for(int i=1;i<s1_length;++i)
        for(int j=1;j<s2_length;++j)
            if(s1[i]==s2[j])
            {
                arr[i][j]=arr[i-1][j-1]+1;
                pre[i][j]=UP_LEFT;
            }
            else
            {
                if(arr[i-1][j]==arr[i][j-1])
                {
                    arr[i][j]=arr[i-1][j];
                    pre[i][j]=LEFTORUP;
                }
                else if(arr[i-1][j]>arr[i][j-1])
                {
                    arr[i][j]=arr[i-1][j];
                    pre[i][j]=UP;
                }
                else
                {
                    arr[i][j]=arr[i][j-1];
                    pre[i][j]=LEFT;
                }
            }

    print_LCS(s1_length-1,s2_length-1);
}

void print_LCS(int i,int j)
{
    if(i==0||j==0)
        return;

    if(pre[i][j]==UP_LEFT)
    {
        cout<<s1[i]<<'\t';
        print_LCS(i-1,j-1);
    }
    else if(pre[i][j]==UP)
        print_LCS(i-1,j);
    else if(pre[i][j]==LEFT)
        print_LCS(i,j-1);
}

以上情况中两个序列只存在一个LCS，但是若存在多个LCS应该怎么解决呢？

若序列s1：2,5,7,9,3,1,2

         s2：3,5,3,2,8,7,9

则LCS为：5,3,2; 2,7,9; 5,7,9

以上两个表格为算法的思路，上面表格为顺序思路，arr[i][j]表示s1(1:i) s2(1:j)两个序列的LCS长度，下面表格为回溯思路，从右下角开始根据方向得到LCS，其中数字意义为：

 LEFT=1;
 UP=2;
 UP_LEFT=3;
 LEFTORUP=4;顺序时由上面或左面数字得到（区别于只有一个LCS存在），目的在于回溯时可以得到序列所有的LCS，代码还没有实现。

 

关于最长字串：

若序列s1：2,5,3,2,7,91,

         s2：3,5,3,2,8

则最长字串：5,3,2

算法：lcs(i,j) = lcs(i-1,j-1) + 1，otherwise：lcs(i,j) = 0 ，相比于不连续情况：

LCS(s1, s2) ={ LCS(sub1, s2) or LCS (s1, sub2) or LCS(sub1, sub2) , when e1 != e2 // LCS(sub1, sub2) + e1, when e1 == e2}

具体代码：

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

int stringLCS(string str1,string str2)
{
    int len1=str1.size();
    int len2=str2.size();

    vector<vector<int> >arr(len1);
    for(int i=0;i<len1;++i)
        arr[i].resize(len2);
    for(int i=0;i<len1;++i)
        for(int j=0;j<len2;++j)
            arr[i][j]=0;

    //(inx,iny):最长字串最后一个字符坐标
    int inx=-1;
    int iny=-1;
    //初始化字串长度
    int maxLength=0;
    for(int i=0;i<len1;++i)
        for(int j=0;j<len2;++j)
        {
            if(str1[i]==str2[j])
            {
                if(i==0||j==0)
                {
                    arr[i][j]=1;
                    //更新字串长度及坐标
                    if(arr[i][j]>maxLength)
                    {
                        inx=i;
                        iny=j;
                        maxLength=arr[i][j];
                    }
                }
                else
                {
                    if(arr[i-1][j-1]!=0)
                        arr[i][j]=arr[i-1][j-1]+1;
                    else
                        arr[i][j]=1;

                    if(arr[i][j]>maxLength)
                    {
                        inx=i;
                        iny=j;
                        maxLength=arr[i][j];
                    }
                }
            }
        }

    //输出相同字串
    for(int i=inx,j=iny;i>=0&&j>=0;--i,--j)
    {
        if(arr[i][j]==0)
            break;
        else
            cout<<str1[i]<<ends;
    }
    cout<<endl;

    return maxLength;
}

int main()
{
    string str1="helloworld";
    string str2="oword";

    cout<<stringLCS(str1,str2)<<endl;
    return 0;
}