字符串应用之最长公共子序列和最长公共子串

最新推荐文章于 2024-08-23 20:07:50 发布

NearXDU

最新推荐文章于 2024-08-23 20:07:50 发布

阅读量653

点赞数 1

分类专栏：数据结构与算法分析数据结构与算法分析文章标签： LCS 动态规划字符串

本文链接：https://blog.csdn.net/zhangxiao93/article/details/54882478

版权

数据结构与算法分析同时被 2 个专栏收录

35 篇文章 1 订阅

订阅专栏

数据结构与算法分析

15 篇文章 5 订阅

订阅专栏

最长公共子序列

$X_m$ 表示X串的前m个字符，即 ${x_0,x_1...x_{m-1}}$
$LCS(X_m,Y_n)$ 即X的前m个字符和Y的前n个字符的最长公共子序列。

动规方程如下：

L C S (X m, Y n) = {L C S (X m - 1, Y n - 1) + X m m a x (L C S (X m - 1, Y n), L C S (X m, Y n - 1)), x m = x n, x m \neq y n

$LCS(X_m,Y_n)= \begin{cases} LCS(X_{m-1},Y_{n-1})+X_m&,{x_m=x_n}\\ max(LCS(X_{m-1},Y_n),LCS(X_m,Y_{n-1}))&, {x_m\neq y_n} \end{cases}$

//最长公共子序列
int longestCommonSubsequence(string A, string B) {
    int m = A.size();
    int n = B.size();
    vector<vector<int>>dp(m + 1, vector<int>(n + 1));
    for (int i = 0; i < m; ++i)
    {
        for (int j = 0; j < n; ++j)
        {
            if (A[i] == B[j])
            {
                dp[i + 1][j + 1] = dp[i][j] + 1;
            }
            else
            {
                dp[i + 1][j + 1] = max(dp[i][j + 1], dp[i + 1][j]);

            }
        }
    }

    int i = m - 1;
    int j = n - 1;
    string s;
    //记录最长子序列并打印
    while (i != -1 && j != -1)
    {
        if (A[i] == B[j])
        {
            s += A[i];
            --i;
            --j;
        }
        else
        {
            if ( (dp[i+1][j ] > dp[i ][j+1]))
            {
                --j;
            }
            else
            {
                --i;
            }
        }
    }

    string res(s.rbegin(), s.rend());
    cout << res << endl;
    return dp[m][n];
    // write your code here
}

最长公共子串

最长公共子串，由于匹配的字串必须在A、B串都是连续的，因此在更新dp[i][j]的时候只能从dp[i-1][j-1]。

//最长公共字串
int longestCommonSubstring(string &A, string &B) {
    // write your code here
    size_t m = A.size();
    size_t n = B.size();
    int res = 0;
    vector<vector<int>> dp(m, vector<int>(n));

    for (int i = 0; i < static_cast<int>(m); ++i)
    {
        for (int j = 0; j < static_cast<int>(n); ++j)
        {
            if (A[i] == B[j])
            {
                if (i>0 && j>0)
                {
                    dp[i][j] = dp[i - 1][j - 1] + 1;
                }
                else
                {
                    dp[i][j] = 1;
                }
            }
            if (res < dp[i][j])
            {
                res = dp[i][j];
            }
        }
    }
    return res;
}