【算法】最长公共子序列（LCS）

已于 2022-09-22 14:52:38 修改
阅读量411 收藏
点赞数
分类专栏： 算法 动态规划 文章标签： 算法 动态规划
于 2020-08-07 23:04:26 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_27198345/article/details/107872245
版权

1. 概述

题目描述：给定两个字符串（或数字序列）A和B，求一个字符串，使得这个字符串是A和B的最长公共部分（子序列可以是补连续的）
例如：“sadstory” 和 “adminstory” 的最长公共子序列是 “adsory”，长度为6


2. 分析

动态规划（Dynamic Programming）
令dp[i][j]表示A的前i个字符和B的前j个字符之间的LCS的长度（下标从1开始），如dp[4][5]表示"sads"和"admin"的LCS长度。那么可以根据A[i]和B[j]的情况，分成两种策略：

  1. 若A[i] == B[j]，则字符串A和B的LCS增加了1位，即有dp[i][j] = dp[i - 1][j - 1] + 1;
  2. 若A[i] != B[j]，则字符串A和字符串B之间的LCS的最大长度继承自dp[i - 1][j]和dp[i][j - 1]的最大者，即dp[i][j] = max(dp[i - 1][j], dp[i][j - 1]);

边界条件
这里下标计数要从1开始，因为我们要构造边界条件d[i][0] = 0和d[0][j] = 0，表示A的前 i 个字符和B的前0个字符LCS长度为0，A的前0个字符和B的前 j 个字符LCS长度为0.


3. 代码及测试

根据以上分析得到了动态规划的转移方程，就可以写出代码了：

Java

public class Solution {
    public static void main(String[] args) {
        String A = "ABCBDAB", B = "BDCABA";
        int lenA = A.length(), lenB = B.length();
        int[][] dp = new int[lenA + 1][lenB + 1];
        for (int i = 1; i < lenA + 1; i++) {
            for (int j = 1; j < lenB + 1; j++) {
                if (A.charAt(i - 1) == B.charAt(j - 1)) {
                    dp[i][j] = dp[i - 1][j - 1] + 1;
                } else {
                    dp[i][j] = Math.max(dp[i - 1][j], dp[i][j - 1]);
                }
            }
        }
        for (int i = 0; i < lenA + 1; i++) {
            for (int j = 0; j < lenB + 1; j++) {
                System.out.print(dp[i][j] + " ");
            }
            System.out.println();
        }
        System.out.println("LCS: " + dp[lenA][lenB]);
    }
}


打印出dp矩阵可以得到：
0 0 0 0 0 0 0 
0 0 0 0 1 1 1 
0 1 1 1 1 2 2 
0 1 1 2 2 2 2 
0 1 1 2 2 3 3 
0 1 2 2 2 3 3 
0 1 2 2 3 3 4 
0 1 2 2 3 4 4 
LCS: 4

C++

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

int main() {
    string A = "ABCBDAB", B = "BDCABA";
    int lenA = A.size(), lenB = B.size();
    vector<vector<int>> dp(lenA + 1, vector<int>(lenB + 1, 0));
    for (int i = 1; i < lenA + 1; i++) {
        for (int j = 1; j < lenB + 1; j++) {
            if (A[i - 1] == B[j - 1]) {
                dp[i][j] = dp[i - 1][j - 1] + 1;
            } else {
                dp[i][j] = max(dp[i - 1][j], dp[i][j - 1]);
            }
        }
    }
    for (int i = 0; i < lenA + 1; i++) {
        for (int j = 0; j < lenB + 1; j++) {
            cout << dp[i][j] << " ";
        }
        cout << endl;
    }
    cout << "LCS: " << dp[lenA][lenB] << endl;
    return 0;
}

0 0 0 0 1 1 1 
0 1 1 1 1 2 2 
0 1 1 2 2 2 2 
0 1 1 2 2 3 3 
0 1 2 2 2 3 3 
0 1 2 2 3 3 4 
0 1 2 2 3 4 4 
LCS: 4

4. 求所有的Longest Common Substring

如果要得到具体的最长公共子序列，就需要在得到的dp数组回溯
每次 dp[i][j] = dp[i - 1][j - 1] +1 时LCS就添加一个字符到末尾，因此可以根据这个性质来得到最长子序列。

Java

import java.util.ArrayList;
import java.util.List;

public class Solution {
    public static void main(String[] args) {
        String A = "ABCBDAB", B = "BDCABA";
        int lenA = A.length(), lenB = B.length();
        int[][] dp = new int[lenA + 1][lenB + 1];
        for (int i = 1; i < lenA + 1; i++) {
            for (int j = 1; j < lenB + 1; j++) {
                if (A.charAt(i - 1) == B.charAt(j - 1)) {
                    dp[i][j] = dp[i - 1][j - 1] + 1;
                } else {
                    dp[i][j] = Math.max(dp[i - 1][j], dp[i][j - 1]);
                }
            }
        }
        for (int i = 0; i < lenA + 1; i++) {
            for (int j = 0; j < lenB + 1; j++) {
                System.out.print(dp[i][j] + " ");
            }
            System.out.println();
        }
        List<String> res = new ArrayList<>();
        allLCS(A, B, dp, lenA, lenB, res, new StringBuilder()); //从dp数组的最后位置向前回溯
        System.out.println("LCS: " + dp[lenA][lenB]);
        System.out.println(res);
    }

    public static void allLCS(String A, String B, int[][] dp, int i, int j, List<String> res, StringBuilder str) {
        if (i == 0 || j == 0) { // 回溯边界
            StringBuilder temp = new StringBuilder(str);
            res.add(temp.reverse().toString());
        } else {
            if (A.charAt(i - 1) == B.charAt(j - 1)) {
                str.append(A.charAt(i - 1));
                allLCS(A, B, dp, i - 1, j - 1, res, str);
                str.deleteCharAt(str.length() - 1);  // DFS退出后将当前字符从后面删除
            } else {
                if (dp[i - 1][j] > dp[i][j - 1]) { // dp[i][j]来自左边，则向左边回溯
                    allLCS(A, B, dp, i - 1, j, res, str);
                } else if (dp[i][j - 1] > dp[i - 1][j]) { // dp[i][j]来自上面，则向上回溯
                    allLCS(A, B, dp, i, j - 1, res, str);
                } else { //两个相等，都可以，因此两个方向都要回溯
                    allLCS(A, B, dp, i -1, j, res, str);
                    allLCS(A, B, dp, i, j - 1, res, str);
                }
            }
        }
    }
}

0 0 0 0 0 0 0 
0 0 0 0 1 1 1 
0 1 1 1 1 2 2 
0 1 1 2 2 2 2 
0 1 1 2 2 3 3 
0 1 2 2 2 3 3 
0 1 2 2 3 3 4 
0 1 2 2 3 4 4 
LCS: 4
[BCBA, BCAB, BDAB]

C++

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

void allLCS(string A, string B, vector<vector<int>>& dp, int i, int j, vector<string>& res, string str) {
    if (i == 0 || j == 0) {
        reverse(str.begin(), str.end());
        res.push_back(str);
    } else {
        if (A[i - 1] == B[j - 1]) {
            str.push_back(A[i - 1]);
            allLCS(A, B, dp, i - 1, j - 1, res, str);
            str.pop_back();
        } else {
            if (dp[i - 1][j] > dp[i][j - 1]) {
                allLCS(A, B, dp, i - 1, j, res, str);
            }
            else if (dp[i][j - 1] > dp[i - 1][j]) {
                allLCS(A, B, dp, i, j - 1, res, str);
            }
            else {
                allLCS(A, B, dp, i - 1, j, res, str);
                allLCS(A, B, dp, i, j - 1, res, str);
            }
        }
    }
}

int main() {
    string A = "ABCBDAB", B = "BDCABA";
    int lenA = A.size(), lenB = B.size();
    vector<vector<int>> dp(lenA + 1, vector<int>(lenB + 1, 0));
    for (int i = 1; i < lenA + 1; i++) {
        for (int j = 1; j < lenB + 1; j++) {
            if (A[i - 1] == B[j - 1]) {
                dp[i][j] = dp[i - 1][j - 1] + 1;
            } else {
                dp[i][j] = max(dp[i - 1][j], dp[i][j - 1]);
            }
        }
    }
    for (int i = 0; i < lenA + 1; i++) {
        for (int j = 0; j < lenB + 1; j++) {
            cout << dp[i][j] << " ";
        }
        cout << endl;
    }
    cout << "LCS: " << dp[lenA][lenB] << endl;
    vector<string> res;
    allLCS(A, B, dp, lenA, lenB, res, "");
    for (int i = 0; i < res.size(); i++) {
        cout << res[i] << " ";
    }
    cout << endl;
    return 0;
}

0 0 0 0 0 0 0 
0 0 0 0 1 1 1 
0 1 1 1 1 2 2 
0 1 1 2 2 2 2 
0 1 1 2 2 3 3 
0 1 2 2 2 3 3 
0 1 2 2 3 3 4 
0 1 2 2 3 4 4 
LCS: 4
BCBA BCAB BDAB

5. 参考文献

  1. 算法笔记，胡凡，曾磊等.
Kant101
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
最长公共子序列算法（LCS）
菜鸟哆哆的专栏
07-19 3380
一、问题描述         LCS算法，找出两个字符串最大匹配子串。 二、解题思路         设置两个矩阵，一个保存每次字符匹配的最大结果值，一个保存匹配符号。                 在按行按列逐个字符匹配的过程中，                 若匹配相同，则把上一次匹配的数量值加一（一般是矩阵左上角的数值），同时更新标记矩阵。         若不匹...
最长公共子序列（LCS）
严霜九月
01-10 363
LCS算是动态规划中比较经典的一道题目，很多书上都讲了这个，题目的描述大概就是有两个序列，从两个序列中找到一个序列（这个序列的长度&lt;=两个序列长度的最小值）使得这个序列是开始的两个序列的子序列。这个题如果用穷举法将所有的序列找到，求出最长公共子序列，这种解法的复杂度是O(2^m)。 因为是动态规划的经典题目，所有特点很明显。 最优子结构（子问题的最优解是原问题的最优解），例如两个字符序列...
求最长公共子序列的LCS算法
12-26
实现了求最长公共子序列的算法，内容简单易懂，代码也很短
最长公共子序列（LCS）算法
Jitwxs
11-13 2610
一、最长公共字串与最长公共子序列 最长公共子串（Longest Common Substirng） 子串是串的一个连续的部分，子串中字符的位置必须连续。 例如：有两个字符串ABCBDAB 和 BDCABA，则它们的最长公共子串是：AB。 最长公共子序列（Longest Common Subsequence，LCS） 子序列是从串中去掉任意的元素而获得新的序列，子串中字符的位置不必...
详解最长公共子序列问题（三种方法）
CXR_XC的博客
03-30 1万+
C++分别利用三种动态规划解决最长公共子序列问题
最长公共子串LCS (Longest Common Subsequence) 算法
Miss Z的博客
08-17 2181
三个方法都有所借鉴，但代码部分是自己试着写出来的，虽然最后的运行结果都是正确的，但此过程中难免会有考虑不周全的地方，如发现代码某些地方有误，欢迎指正。同时有新的想法，也可以提出! 采用顺序结构存储串，求串s和串t的一个最长公共子串。 方法一 算法思想：借助二维数组可以求出最长公共子串最后一个字符分别在s串和t串中的数组下标。此时可以从s中截取最长公共子串，也可以从t中截取。 SqString MaxComStr(SqString s, SqString t) { SqString str; in
最长公共子序列(LCS) 过程图解
03-18 8232
1.基本概念 首先需要科普一下，最长公共子序列（longest common sequence）和最长公共子串（longest common substring）不是一回事儿。什么是子序列呢？即一个给定的序列的子序列，就是将给定序列中零个或多个元素去掉之后得到的结果。什么是子串呢？给定串中任意个连续的字符组成的子序列称为该串的子串。给一个图再解释一下： 如上图，给定的字符序列： {a,b,c,d,e,f,g,h}，它的子序列示例： {a,c,e,f} 即元素b,d,g,h被...
LCS算法：最长公共子序列
氵青-风的博客
12-16 1275
LCS算法：最长公共子序列定义： 一个序列A任意删除若干个字符得到新序列B，则A叫做B的子序列 两个序列X和Y的公共子序列中，长度最长的那个，定义为X和Y的最长公共子序列 例如：X={A,B,C,B,D,A,B} Y={B,D,C,A,B,A} 则它们的lcs分别是 {B,C,B,A} {B,D,A,B}。 求出一个即可。 LCS的LCS算法符号表示： 字符串X,长度m,从1开始计数 字符串
Java算法之最长公共子序列问题(LCS)实例分析
08-28
Java算法之最长公共子序列问题（LCS）实例分析主要介绍了Java算法之最长公共子序列问题（LCS），结合实例形式分析了最长公共子序列的原理及问题解决方法。 问题描述：一个给定序列的子序列是在该序列中删去若干...
python实现最长公共子序列
09-20
最长公共子序列（Longest Common Subsequence，LCS）是一个在计算机科学中常见的问题，它涉及到寻找两个序列的最长子序列，这个子序列不需要在原序列中连续出现，但必须保持原有顺序。在这个问题中，我们将关注如何...
Ruby实现的最长公共子序列算法
09-22
本篇文章将深入探讨在Ruby编程语言中实现最长公共子序列（LCS）算法的过程。最长公共子序列问题是一个经典的计算机科学问题，通常通过动态规划方法解决。在本文中，我们将分析提供的Ruby代码，并解释其实现细节。 #...
lcs_最长公共子序列_
10-01
总结一下，最长公共子序列是一种计算序列相似性的算法，通过动态规划求解。它在处理文本比较、序列比对等问题时非常有用。在实际编程中，我们需要理解状态转移方程，构建并填充二维数组，最后通过回溯找到具体子序列...
lcs.rar_LCS_最长公共子序列
09-24
最长公共子序列（Longest Common Subsequence, LCS）是计算机科学中一种经典的字符串问题，尤其在算法设计和分析中占有重要地位。这个问题的目标是找到两个或多个序列的最长子序列，这个子序列并不需要在原序列中...
【动态规划】最长公共子序列——算法设计与分析
友人帐_的博客
02-08 4234
介绍了最长公共子序列问题及其相关概念，并按照动态规划基本步骤给出求解策略以及算法实例，分析了算法复杂度。
LCS 问题：最长公共子序列/最长公共子串
To be a great coder
07-26 487
最长公共子序列 求两个字符串的最长公共子序列（Longest Common Sequence，简称 LCS），比如： A = “abcdefg” B = “acbeg" 那么这两个字符串的最长公共子序列便是：“aceg”。 对于这种求取”最“值的问题，非常容易想到会使用动态规划来求解。使用动态规划解决问题其实并没有多难，它只需要你做好两件事即可： 对状态做一个好的定义（即你的 dp 数组中的...
获取两个字符串的最大公共子序列(LCS)
Mark_Australia的博客
09-19 3069
LCS
算法：最长公共子序列（做法小计）
m0_73755253的博客
06-27 640
给出长度为n的数组a，长度为m的数组b，求解其最长公共子序列
数据结构与算法之最长公共子序列
最新发布
weixin_47225948的博客
09-20 1483
数据结构与算法之最长公共子序列
【算法】桶排序（Bucket Sort）详解
热门推荐
qq_27198345的博客
08-25 2万+
桶排序
最长公共子序列LCS
08-15
最长公共子序列（Longest Common Subsequence, LCS）是指两个序列中最长的公共子序列的长度。 假设有两个序列A和B，长度分别为n和m。我们可以使用动态规划算法来求解LCS的长度。 定义dp[i][j]表示序列A的前i个元素...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值