最长共公共子序列和最长公共子串

参考：http://www.cnblogs.com/zhangchaoyang/articles/2012070.html

最长公共子序列

最长公共子序列与最长公共子串的区别在于最长公共子序列不要求在原字符串中是连续的，比如ADE和ABCDE的最长公共子序列是ADE。

我们用动态规划的方法来思考这个问题如是求解。首先要找到状态转移方程：

符号约定，C1是S1的最右侧字符，C2是S2的最右侧字符，S1‘是从S1中去除C1的部分，S2’是从S2中去除C2的部分。

LCS(S1,S2)等于下列3项的最大者：

（1）LCS（S1，S2’）如果C1!=C2

（2）LCS（S1’，S2） 如果C1!=C2

（3） LCS（S1’，S2’）+C1 如果C1==C2；

边界终止条件：如果S1和S2都是空串，则结果也是空串。

以上理解：每次比较S1和S2时，有三种可能：
        1. S1 S2最后一个字符相等，那么直接将两者除去这个字符的公共子序列长度加一即可；
        2. S1 S2最后一个字符不等，那么又有两种情况：
            i. S1与S2去掉最后一个字符的序列相比， 得到子序列长度
            ii. S1去掉最后一个字符与S2相比，得到子序列长度
            最终选择i和ii中最大的长度作为S1与S2的公共子序列长度

下面我们同样要构建一个矩阵来存储动态规划过程中子问题的解。这个矩阵中的每个数字代表了该行和该列之前的LCS的长度。与上面刚刚分析出的状态转移相对应，矩阵中每个格子里的数字应该这么填，它等于以下3项的最大值：

（1）上面一个格子里的数字

（2）左边一个格子里的数字

（3）左上角格子里的数字+1（C1==C2时）

举个例子：

　　　　 G　　C　　T　　A

　　 0　　0　　0　　0　　0

G　 0　　1　　1　　1　　1

B　 0　　1　　1　　1　　1

T　 0　　1　　1　　2　　2

A 0　　1　　1　　2　　3

填写最后一个数字时，它应该是下面三个的最大者：

（1）上边的数字2

（2）左边的数字2

（3）左上角的数字2+1=3,因为此时C1==C2

所以最终结果是3。

在填写过程中我们还是记录下当前单元格的数字来自于哪个单元格，以方便最后我们回溯找出最长公共子串。由于每个格子可能来自于多个方向，如果想把所有可能的公共子序列全部输出的话，需要分别标记左、上、左上、左或左上四中可能，且回溯的时候如果遇到左上的情况，又需要递归回溯；所以为了方便以下程序中并没有把所有子序列都打印出来。

int lcs1(string a, string b)//最长共公共子序列
{
    int D[8][7];//D记录当前最长的公共子序列长度
    int S[7][6];//记录方向
    for (int i = 0; i <= a.length(); i++)
        D[i][0] = 0;
    for (int j = 0; j < b.length(); j++)
        D[0][j] = 0;
    //初始化第一行和第一列为0
    for (int i = 0; i < a.length(); i++)
    {
        for (int j = 0; j < b.length(); j++)
        {
            if (a[i] == b[j])
            {
                D[i + 1][j + 1] = D[i][j] + 1;
                S[i][j] = 0;//字符相等标记为0
            }
            else
            {
                D[i + 1][j + 1] = ((D[i][j + 1]>D[i + 1][j]) ? D[i][j + 1] : D[i + 1][j]);
                S[i][j] = ((D[i][j + 1] > D[i + 1][j]) ? -1 : 1);//从上传递来标记为-1，从左传递来标记1
            }
        }
    }
    cout << "公共子序列：";//如果想打印所有可能的子序列，需要单独用递归来打印，考虑左、上都有可能的情况
    int l = a.length() - 1;
    int r = b.length() - 1;
    while ((l >= 0) && (r>=0))
    {
        if (S[l][r] == 0)
        {
            cout << a[l] << " ";
            l--; r--;
        }
        else if (S[l][r] == -1)
            l--;
        else
            r--;
    }
    return D[6][5];
}

最长公共子串

找两个字符串的最长公共子串，这个子串要求在原字符串中是连续的。我们采用一个二维矩阵来记录中间的结果。这个二维矩阵怎么构造呢？直接举个例子吧：”bab”和”caba”(当然我们现在一眼就可以看出来最长公共子串是”ba”或”ab”)

　　 b　　a　　b

c　　0　　0　　0

a　　0　　1　　0

b　　1　　0　　1

a　　0　　1　　0

我们看矩阵的斜对角线最长的那个就能找出最长公共子串。

不过在二维矩阵上找最长的由1组成的斜对角线也是件麻烦费时的事，下面改进：当要在矩阵是填1时让它等于其左上角元素加1。

　　 b　　a　　b

c　　0　　0　　0

a　　0　　1　　0

b　　1　　0　　2

a　　0　　2　　0

这样矩阵中的最大元素就是 最长公共子串的长度。
输出子串的时候，找到矩阵中max所在的位置，然后循环max次即可得到字符串。

int lcs2(string a, string b)
{
    int D[8][7];
    for (int i = 0; i <= a.length(); i++)
        D[i][0] = 0;
    for (int i = 0; i <= b.length(); i++)
        D[0][i] = 0;
    //初始化
    int max = 0;//记当前最长子串的长度
    for (int i = 0; i < a.length(); i++)
    {
        for (int j = 0; j < b.length(); j++)
        {
            if (a[i] == b[j])
            {
                D[i+1][j+1] = D[i][j] + 1;//字符串相等就加一
                max = (D[i+1][j+1]>max) ? D[i+1][j+1] : max;
            }
            else
            {
                D[i+1][j+1] = 0;
            }
        }
    }
    for (int i = a.length(); i > 0; i--)//打印出所有的子串
    {
        for (int j = b.length(); j > 0; j--)
        {
            if (D[i][j] == max)
            {
                int t = i;
                for (int x = 0; x < max;x++)
                {
                    cout << a[t-1] << " ";
                    t--;
                }
                cout << endl;
            }
        }
    }
    return max;
}