公共子序列

最长公共子序列

---

给出两个字符串，找到最长公共子序列(LCS)，返回LCS的长度。

最长公共子序列的定义：
最长公共子序列问题是在一组序列（通常2个）中找到最长公共子序列（注意：不同于子串，LCS不需要是连续的子串）。该问题是典型的计算机科学问题，是文件差异比较程序的基础，在生物信息学中也有所应用。
最长公共子序列定义链接

样例
给出”ABCD” 和 “EDCA”，这个LCS是 “A” (或 D或C)，返回1
给出 “ABCD” 和 “EACB”，这个LCS是”AC”返回 2

---

考虑最长公共子序列问题如何分解成子问题，设A=“a0，a1，…，am-1”，B=“b0，b1，…，bm-1”，并Z=“z0，z1，…，zk-1”为它们的最长公共子序列。不难证明有以下性质：
（1） 如果am-1=bn-1，则zk-1=am-1=bn-1，且“z0，z1，…，zk-2”是“a0，a1，…，am-2”和“b0，b1，…，bn-2”的一个最长公共子序列；
（2） 如果am-1!=bn-1，则若zk-1!=am-1，蕴涵“z0，z1，…，zk-1”是“a0，a1，…，am-2”和“b0，b1，…，bn-1”的一个最长公共子序列；
（3） 如果am-1!=bn-1，则若zk-1!=bn-1，蕴涵“z0，z1，…，zk-1”是“a0，a1，…，am-1”和“b0，b1，…，bn-2”的一个最长公共子序列。

这样，在找A和B的公共子序列时，如有am-1=bn-1，则进一步解决一个子问题，找“a0，a1，…，am-2”和“b0，b1，…，bm-2”的一个最长公共子序列；如果am-1!=bn-1，则要解决两个子问题，找出“a0，a1，…，am-2”和“b0，b1，…，bn-1”的一个最长公共子序列和找出“a0，a1，…，am-1”和“b0，b1，…，bn-2”的一个最长公共子序列，再取两者中较长者作为A和B的最长公共子序列。
思路：使用一个二维数组记录当前str1 和 str2 之间的最长公共子序列，可以写成一下形式：

代码如下：

int longestCommonSubsequence(string A, string B) {
    if (A == "" || B == "")return 0;
    int len1 = A.size(), len2 = B.size();
    vector<vector<int>> dp(len1 + 1, vector<int>(len2 + 1, 0));
    int num = INT_MIN;
    for (int i = 1; i <= len1; i++){
        char ch1 = A[i - 1];
        for (int j = 1; j <= len2; j++){
            char ch2 = B[j - 1];
            if (ch2 == ch1)dp[i][j] = dp[i - 1][j - 1] + 1;
            else dp[i][j] = max(dp[i - 1][j], dp[i][j - 1]);
        }
    }
    return dp[len1][len2];
}

交叉字符串

描述：给出三个字符串:s1、s2、s3，判断s3是否由s1和s2交叉构成。

测试用例
比如 s1 = “aabcc” s2 = “dbbca”
->当 s3 = “aadbbcbcac”，返回 true.
->当 s3 = “aadbbbaccc”， 返回 false.

思路1：可以利用递归来来判断s1，s2中的每一个字符和s3中相对应位置字符之间的关系。

void visit(string& s1, int pos1, int len1, string& s2, int pos2, int len2, string& s3, int pos3, int len3, bool& res){
    if (res)return;
    if (pos1 < len1 && s1[pos1] == s3[pos3]){
        visit(s1, pos1 + 1, len1, s2, pos2, len2, s3, pos3 + 1, len3, res);
    }
    if (pos2 < len2 && s2[pos2] == s3[pos3]){
        visit(s1, pos1, len1, s2, pos2 + 1, len2, s3, pos3 + 1, len3, res);
    }
    if (pos1 >= len1 && pos2 >= len2)res = true;
}

bool isInterleave(string s1, string s2, string s3) {
    int len1 = s1.size(), len2 = s2.size(), len3 = s3.size();
    if (len3 != len1 + len2)return false;
    if (len1 == 0)return s3 == s2;
    if (len2 == 0)return s3 == s1;
    bool res = false;
    visit(s1, 0, len1, s2, 0, len2, s3, 0, len3, res);
    return res;
}

思路2：也可以利用动态规划的思想做。

bool isInterleave(string s1, string s2, string s3) {
    int len1 = s1.size(), len2 = s2.size(), len3 = s3.size();
    if (len3 != len1 + len2)return false;
    if (len1 == 0)return s3 == s2;
    if (len2 == 0)return s3 == s1;
    vector<vector<bool>> dp(len1, vector<bool>(len2, false));
    dp[0][0] = true;
    for (int i = 1; i <= len1; i++)dp[i][0] = dp[i - 1][0] && (s1[i - 1] == s3[i - 1]);
    for (int j = 1; j <= len2; j++)dp[0][j] = dp[0][j - 1] && (s2[j - 1] == s3[j - 1]);
    for (int i = 1; i <= len1; i++){
        for (int j = 1; j <= len2; j++){
            int t = i + j;
            if (s1[i - 1] == s3[t - 1])dp[i][j] = dp[i][j] || dp[i - 1][j];
            if (s2[j - 1] == s3[t - 1])dp[i][j] = dp[i][j] || dp[i][j - 1];
        }
    }
    return dp[len1][len2];
}