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

描述：找出两个字符串的最长公共子序列，例如串X = <A, B, C, B, D, A, B>，Y = <B, D, C, A, B, A>，则<B, C>可以算一个公共子序列，但不是最长的，最长的公共子序列为<B, C, A, B>.

算法分析，设序列X = <X_1, X₂, ..., X_m>, Y= <Y₁, Y₂, ..., Y_n>. 设Z = <Z₁, Z₂, ..., Z_k>是X和Y的任意一个LCS，则：

1. 如果X_m == Y_n, 那么 Z_k = X_m = Y_n, 而且 Z_k-1 是 X_m-1 和 Y_n-1 的一个LCS.
2. 如果X_m != Y_n, 那么 Z_k != X_m 蕴含 Z 是 X_m-1 和 Y 的一个LCS.
3. 如果X_m != Y_n, 那么 Z_k != Y_n 蕴含 Z 是 Y_n-1 和 X 的一个LCS.

上述特征说明，两个序列的一个LCS也包含了两个序列的前缀的一个LCS，这说明LCS问题就有最优子结构性质。

那么可以得到递归式：

又递归式可以看出该问题有重复子问题性质，由于为了找 X 和 Y 的一个LCS，可能会求 X 和 Y_n-1 或者是 X_m-1 和 Y 的LCS， 儿这两个子问题又包含找 X_m-1 和 Y_n-1的LCS。

由此我们可以写递归代码来求LCS长度，代码如下：

// LCS.cpp : 定义控制台应用程序的入口点。

#include <iostream>
#include <math.h>
#include <string>
using std::string;

int max(int a, int b){ return a > b ? a : b; }
int LCSRecursive(const string &strX, const string &strY, const int &m, const int &n)
{
    if (m == 0 || n == 0)
        return 0;
    if (strX[m] == strY[n])
    {
        return LCSRecursive(strX, strY, m - 1, n - 1) + 1;
    }
    else
    {
        return max(LCSRecursive(strX, strY, m - 1, n), LCSRecursive(strX, strY, m, n - 1));
    }
}


int main(int argc, char **argv)
{
    const string strX = "ABCDAB";
    const string strY = "BDCABA";

    int LCSLength = LCSRecursive(strX, strY, strX.size(), strY.size());

    std::cout << "The Length of the Longest common subsequence is: " << LCSLength << std::endl;
    
    return 0;
}

 非递归如下：

int LCSNoneRecursive(const string &strX, const string &strY)
{
    // 是字符串从下标1开始，便于C数组计算
    string X = " " + strX;
    string Y = " " + strY;

    int m = X.size();
    int n = Y.size();
    int **c = new int*[m];

    // 申请内存存储C数组
    for (int i = 0; i < m; ++i)
        c[i] = new int[n];

    for (int i = 0; i < m; ++i)
        c[i][0] = 0;

    for (int j = 0; j < n; j++)
        c[0][j] = 0;

    // 计算C数组的值
    for (int i = 1; i < m; i++)
        for (int j = 1; j < n; j++)
        {
            if (X[i] == Y[j])
                c[i][j] = c[i - 1][j - 1] + 1;
            else
            {
                if (c[i][j - 1] >= c[i - 1][j])
                    c[i][j] = c[i][j - 1];
                else
                    c[i][j] = c[i - 1][j];
            }
        }
    // 最长公共子序列长度为最右下角的元素
    int LCSLength = c[m - 1][n - 1];
    for (int i = 0; i < m; i++)
        delete c[i];
    delete []c;
    return LCSLength;
}