动态规划之最长公共子序列（LCS）原理及C++与Python实现

最新推荐文章于 2024-08-10 19:35:28 发布
最新推荐文章于 2024-08-10 19:35:28 发布
阅读量4.6k 收藏 13
点赞数 7
分类专栏： 算法 文章标签： 最长公共子序列 LCS 动态规划 C Python
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/bqw18744018044/article/details/79855683
版权

一、基本概念

 

二、穷举算法的时间复杂度

 

三、分析子问题

 

四、递推方程和标记函数

 

 

五、算法LCS

1. 伪代码

算法：LCS(X,Y,m,n)

输入：序列X及其长度m，序列Y及其长度n

输出：最长公共子序列的长度

for iß0 to m do

  C[i,0]ß0

for jß0 to n do

  C[0,j]

for iß1 to m do

  for jß1 to n do

if X[i]=Y[j]

then C[i,j]=C[i-1,j-1]+1

    B[i,j]=’↖’

else if C[i-1,j]>=C[i,j-1]

    then C[i,j]ßC[i-1,j]

        B[i,j]ß’’

    else C[i,j]ßC[i,j-1]

        B[i,j]ß’’

 

2. C/C++实现

/********************************************************
Function:LCS
Description:计算两个字符串的最长公共子序列.
Input:字符串s1,s2
Output:最长公共子序列(LCS)的长度
*********************************************************/
int LCS(string s1,string s2){
    int m = s1.size()+1;
    int n = s2.size()+1;

    /*申请二维数组B和C*/
    /*
    C是优化函数值矩阵
    C[i][j]表示s1的前i个元素和s2的前j个元素的最长公共子序列的长度
    */
    int** C = new int* [m];
    for(int i=0;i<m;i++)
        C[i] = new int [n];
    /*
    B是标记函数值矩阵，记录当前优化函数值是从那个方向来的
    B中元素取值解释--0：左，1：上，2：左上
    */
    int** B = new int* [m];
    for(int i=0;i<m;i++)
        B[i] = new int [n];

    /*
    初始化B和C矩阵的第0行与第0列
    C[i][0]表示s1的前i个字符与s2的前0个字符的
    公共子序列的长度，显然其值为0；C[0][j]与C[i][j]相同；
    */
    for(int i=0;i<m;i++){
        C[i][0] = 0;
        B[i][0] = 0;
    }
    for(int j=0;j<n;j++){
        C[0][j] = 0;
        B[0][j] = 0;
    }
    /*
    动态规划过程，逐步填表
    由小到大逐步计算C[i][j]和B[i][j]
    */
    for(int i=1;i<m;i++){
        for(int j=1;j<n;j++){
            if(s1[i-1]==s2[j-1]){
                C[i][j] = C[i-1][j-1]+1;
                B[i][j] = 2;
            }else{
                if(C[i-1][j]>=C[i][j-1]){
                    C[i][j] = C[i-1][j];
                    B[i][j] = 0;
                }else{
                    C[i][j] = C[i][j-1];
                    B[i][j] = 1;
                }
            }
        }
    }
    return C[m-1][n-1];
}

 

3. Python实现 

def LCS(s1,s2):
    """
    计算两个字符串的最长公共子序列.
    
    Parameters
    ----------
    s1：字符串
    
    s2：字符串
    
    Returns
    -------
    B：二维Numpy数组
        标记函数值组成的矩阵
        
    C：二维Numpy数组
        优化函数值组成的矩阵
    """
    m = len(s1)+1
    n = len(s2)+1;
    # 优化函数值矩阵
    # C[i][j]表示s1的前i个元素和s2的前j个元素的最长公共子序列的长度
    C = np.zeros((m,n))
    # 标记函数值矩阵
    # 记录当前优化函数值是从那个方向来的
    # B中元素取值解释--0：左，1：上，2：左上
    B = np.zeros((m,n))
    for i in range(1,m):
        for j in range(1,n):
            if s1[i-1]==s2[j-1]:
                C[i][j] = C[i-1][j-1]+1
                B[i][j] = 2
            else:
                if C[i-1][j]>=C[i][j-1]:
                    C[i][j] = C[i-1][j]
                    B[i][j] = 0
                else:
                    C[i][j] = C[i][j-1]
                    B[i][j] = 1
    return B,C

4. 时间复杂度与空间复杂度 

算法完成时需要将m*n矩阵C和B填充完，而每填充一项是时间是O(1)，因此该算法的时间复杂度是O(mn)。该算法需要的额外空间主要是矩阵B和C，其大小均为m*n，因此空间复杂度为O(mn).

 

六、反向构造LCS

1. 伪代码

算法：struct_sequence

输入：标记矩阵B，B最后一个元素的坐标(i,j)

输出：最长公共子序列

if i=0 or j=0 return

if B[i,j]=’↖’

then struct_sequence(B,i-1,j-1)

    输出X[i]

else if B[i,j]=’’

then struct_sequence(B,i-1,j)

else struct_sequence(B,i,j-1)

 

2. C/C++实现

 

/**********************************************************************
Function:struct_sequece
Description:通过给定标记矩阵B，反向求出LCS
Input:标记矩阵B，B右下角坐标(i,j)，字符串s1和s2
Output：LCS
***********************************************************************/
void struct_sequence(int ** B,int i,int j,string s1,string s2){
    if(i==0||j==0)
        return;
    switch(B[i][j]){
        case 0://左
            struct_sequence(B,i-1,j,s1,s2);
            break;
        case 1://上
            struct_sequence(B,i,j-1,s1,s2);
            break;
        case 2://左上
            struct_sequence(B,i-1,j-1,s1,s2);
            cout<<s1[i-1]<<" ";
            break;
    }
}

3.Python实现 

def struct_sequence(B,i,j,s1,s2):
    """
    根据标记函数值矩阵输出最长公共子序列
    
    Parameters:
    -----------
    B：二维Numpy数组
        标记函数值组成的矩阵
        
    i,j：B矩阵中当前需要判断值的坐标
    
    s1：字符串
    
    s2：字符串
    """
    if i==0 or j==0: #base case
        return 0
    if B[i,j] == 2:
        struct_sequence(B,i-1,j-1,s1,s2)
        print(s1[i-1],end=' ')
    elif B[i,j] == 1:
        struct_sequence(B,i,j-1,s1,s2)
    elif B[i,j] == 0:
        struct_sequence(B,i-1,j,s1,s2)

 

 

 

4.时间复杂度

该算法会沿着某条路径从B矩阵的右下角走到左边界或上边界，最坏情况是从右下角到左上角，时间复杂度为O(m+n).

 

七、完整代码

1.C/C++代码

 

#include <iostream>
#include <string>
using namespace std;
/**********************************************************************
Function:struct_sequece
Description:通过给定标记矩阵B，反向求出LCS
Input:标记矩阵B，B右下角坐标(i,j)，字符串s1和s2
Output：LCS
***********************************************************************/
void struct_sequence(int ** B,int i,int j,string s1,string s2){
    if(i==0||j==0)
        return;
    switch(B[i][j]){
        case 0://左
            struct_sequence(B,i-1,j,s1,s2);
            break;
        case 1://上
            struct_sequence(B,i,j-1,s1,s2);
            break;
        case 2://左上
            struct_sequence(B,i-1,j-1,s1,s2);
            cout<<s1[i-1]<<" ";
            break;
    }
}

/********************************************************
Function:LCS
Description:计算两个字符串的最长公共子序列.
Input:字符串s1,s2
Output:最长公共子序列(LCS)的长度
*********************************************************/
int LCS(string s1,string s2){
    int m = s1.size()+1;
    int n = s2.size()+1;

    /*申请二维数组B和C*/
    /*
    C是优化函数值矩阵
    C[i][j]表示s1的前i个元素和s2的前j个元素的最长公共子序列的长度
    */
    int** C = new int* [m];
    for(int i=0;i<m;i++)
        C[i] = new int [n];
    /*
    B是标记函数值矩阵，记录当前优化函数值是从那个方向来的
    B中元素取值解释--0：左，1：上，2：左上
    */
    int** B = new int* [m];
    for(int i=0;i<m;i++)
        B[i] = new int [n];

    /*
    初始化B和C矩阵的第0行与第0列
    C[i][0]表示s1的前i个字符与s2的前0个字符的
    公共子序列的长度，显然其值为0；C[0][j]与C[i][j]相同；
    */
    for(int i=0;i<m;i++){
        C[i][0] = 0;
        B[i][0] = 0;
    }
    for(int j=0;j<n;j++){
        C[0][j] = 0;
        B[0][j] = 0;
    }
    /*
    动态规划过程，逐步填表
    由小到大逐步计算C[i][j]和B[i][j]
    */
    for(int i=1;i<m;i++){
        for(int j=1;j<n;j++){
            if(s1[i-1]==s2[j-1]){
                C[i][j] = C[i-1][j-1]+1;
                B[i][j] = 2;
            }else{
                if(C[i-1][j]>=C[i][j-1]){
                    C[i][j] = C[i-1][j];
                    B[i][j] = 0;
                }else{
                    C[i][j] = C[i][j-1];
                    B[i][j] = 1;
                }
            }
        }
    }
    cout<<"最长公共子序列为：";
    struct_sequence(B,m-1,n-1,s1,s2);
    return C[m-1][n-1];
}

int main()
{
    /*测试*/
    string s1 = "ABCBDAB";
    string s2 = "BDCABA";
    cout<<endl<<"最长公共子序列长度为："<<LCS(s1,s2);
    return 0;
}

 

2.Python代码 

import numpy as np
def LCS(s1,s2):
    """
    计算两个字符串的最长公共子序列.
    
    Parameters
    ----------
    s1：字符串
    
    s2：字符串
    
    Returns
    -------
    B：二维Numpy数组
        标记函数值组成的矩阵
        
    C：二维Numpy数组
        优化函数值组成的矩阵
    """
    m = len(s1)+1
    n = len(s2)+1;
    # 优化函数值矩阵
    # C[i][j]表示s1的前i个元素和s2的前j个元素的最长公共子序列的长度
    C = np.zeros((m,n))
    # 标记函数值矩阵
    # 记录当前优化函数值是从那个方向来的
    # B中元素取值解释--0：左，1：上，2：左上
    B = np.zeros((m,n))
    for i in range(1,m):
        for j in range(1,n):
            if s1[i-1]==s2[j-1]:
                C[i][j] = C[i-1][j-1]+1
                B[i][j] = 2
            else:
                if C[i-1][j]>=C[i][j-1]:
                    C[i][j] = C[i-1][j]
                    B[i][j] = 0
                else:
                    C[i][j] = C[i][j-1]
                    B[i][j] = 1
    return B,C

def struct_sequence(B,i,j,s1,s2):
    """
    根据标记函数值矩阵输出最长公共子序列
    
    Parameters:
    -----------
    B：二维Numpy数组
        标记函数值组成的矩阵
        
    i,j：B矩阵中当前需要判断值的坐标
    
    s1：字符串
    
    s2：字符串
    """
    if i==0 or j==0: #base case
        return 0
    if B[i,j] == 2:
        struct_sequence(B,i-1,j-1,s1,s2)
        print(s1[i-1],end=' ')
    elif B[i,j] == 1:
        struct_sequence(B,i,j-1,s1,s2)
    elif B[i,j] == 0:
        struct_sequence(B,i-1,j,s1,s2)
        

'''测试代码'''
s1 = "ABCBDAB"
s2 = "BDCABA"
B,C = LCS(s1,s2)
print("LCS的长度为：%d"%C[-1,-1])
struct_sequence(B,B.shape[0]-1,B.shape[1]-1,s1,s2)

 

BQW_
关注
专栏目录
C++ 动态规划-LCS最长公共子序列
_Gion
10-15 2537
最长公共子序列(LCS)
C++ 动态规划经典案例解析之最长公共子序列（LCS）_窥探递归和动态规划的一致性
y6123236的专栏
08-14 2373
动态规划处理字符相关案例中，求最长公共子序列以及求最短编辑距离，算是经典中的经典案例。讲解此类问题的算法在网上一抓应用一大把，即便如此，还是忍不住有写此文的想法。毕竟理解、看懂都不算是真正掌握，唯有瞧出其中玄机，能有自己独有的见解和不一样的感悟方算是把知识学到灵魂深入。好了！闲话少说，进入正题。最长公共子序列很有代表性，分析基于递归和动态规划的实现过程，可以帮助我们理解此类问题，且解决此类问题。
LCS 算法之C++实现
quailzhang的专栏
05-25 4473
    #includeusing namespace std;char* LCS(char* left,char* right);int main(){ char *left,*right; left = new char[1024]; right = new char[1024]; cout  cin >> left; cout  cin >> right; cout  cout  retur
力扣 | 递增子序列 | 动态规划 | 最长递增子序列、最长递增子序列的个数、及其变式
最新发布
m0_63997099的博客
08-10 1019
原序-递增数值问题：原序-定差数值问题：非原序-递增区间问题：非原序-递增二维数值问题。
最长公共子序列(LCS)的算法C++实现-已用模板类封装
10-29
LCS算法的精髓就是动态规划，序列其实不仅限于字符序列，因此我用模版类对该算法进行了封装，里面提供了尽量方便的函数来进行该算法的使用，该实现并不追求速度最快化，而是尽量让该算法类能支持重用，若发现算法有问题可以向我提出建议。
最长公共子序列LCS（c++）
09-11
使用c++语言编写的LCS问题的求解过程
最长公共子序列动态规划c语言,动态规划----最长公共子序列（C++实现）
weixin_39912566的博客
05-22 2238
最长公共子序列题目描述：给定两个字符串s1 s2 … sn和t1 t2 … tm 。求出这两个字符串的最长公共子序列的长度。字符串s1 s2 … sn的子序列指可以表示为 … { i1 < i2 < … < ik }的序列。输入样例2asdfadfsd123abcabc123abc输出样例36解题思路：这道题是被称为最长公共子序列的问题(LCS，Longest Common S...
最长公共子序列（LCS）的python、C、C++、Java实现 LeetCode72、LeetCode1143
xiaomaolin2的博客
10-05 310
最长公共子序列（Longest Common Subsequence，LCS）是一种常见的计算机科学问题，涉及到在两个序列（通常是字符串）中找到最长的子序列，这个子序列是这两个序列共有的。本文将深入探讨LCS的原理、不同编程语言的实现方法，并通过解析Leetcode中的例题来展示其实际应用。
最长公共子序列问题动态规划解决，二个或者三个字符串的
01-09
哈工大算法实验二，最长公共子序列问题，动态规划解决LCS 1.实现基于优化子结构的递归求解算法 2.实现基于动态规划的求解算法 3.实现三个字符串最长公共子序列的动态规划算法 4.有界面源代码和实验报告！均为自己所...
最长公共子序列问题.docx
06-14
最长公共子序列（Longest Common Subsequence, LCS）问题是一个经典的计算机科学问题，它涉及到序列比对、文本编辑距离计算等多个领域。在这个问题中，给定两个字符串或字符序列A和B，目标是找到这两个序列的最长子...
深刻理解最长公共子串、最长公共子序列（应该比较全面）
11-21 2904
这里写自定义目录标题 理论知识： 推荐参考该博文：java实现字符串匹配问题之求两个字符串的最大公共子串 当然这篇也一样，看个人理解：求两个字符串的最长公共子串 图形理解： ...
最长公共子序列算法C++实现
07-25
最长公共子序列问题 for ( i = 0; i < m+1; i++) { c[i] = new int[n+1]; } for(i=0;i<=m;i++) {c[i][0]=0;b[i][0]=0;} for(i=0;i<=n;i++) {c[0][i]=0;b[0][i]=0;} for(i=1;i<=m;i++) for(j=1;j=c[i][j-1]) { c[i][j]=c[i-1][j]; b[i][j]=2; } else { c[i][j]=c[i][j-1]; b[i][j]=3; }
c++算法和数据结构之《LCS》
qq_46615150的博客
04-24 435
文章目录动态规划求解最长公共子序列的结构 动态规划求解最长公共子序列的结构 分析规律： 设X=<x1,x2,x3,x4…,xm>，Y=<y1,y2,y3,y4…,yn>为两个序列，Z=<z1,z2,z3,z4…,zk>是他们的任意公共子序列 经过分析，我们可以知道： 1、如果xm = yn，则zk = xm = yn 且 Zk-1是Xm-1和Yn-1的一个LCS 2、如果xm != yn 且 zk != xm，则Z是Xm-1和Y的一个LCS 3、如果xm != yn 且
算法导论-动态规划(最长公共子序列问题LCS)-C++实现
weixin_30337251的博客
07-12 439
首先定义一个给定序列的子序列，就是将给定序列中零个或多个元素去掉之后得到的结果，其形式化定义如下：给定一个序列X = <x1,x2,..., xm>，另一个序列Z =<z1,z2,..., zk> 满足如下条件时称为X的子序列，即存在一个严格递增的X的下标序列<i1,i2,..., ik>，对于所有j = 1,2,...,k，满足xij ...
最长公共子序列LCS C++实现
lzoi_hmh的博客
08-27 408
#include <iostream> #include <cstdio> #include <cstring> using namespace std;char a[1005],b[1005]; int f[1005][1005];int main() { scanf("%s",a+1); scanf("%s",b+1); int lena=strlen(a+1);
最长公共子序列（LCS）的C++实现
DrJingwuWang的博客
07-26 5119
首先有如下递归式 绘制图表如下 首先我们实现最长公共子序列长度的输出，代码如下： #include #include #include #include using namespace std; int table[100][100] = { 0 }; int main() { string a, b; cin >> a >> b; int m = a.length(); i
算法学习 - 最长公共子序列（LCS）C++实现
热门推荐
累了就歇一会
08-25 1万+
最长公共子序列最长公共子序列的问题很简单，就是在两个字符串中找到最长的子序列，这里明确两个含义： 子串：表示连续的一串字符 。 子序列：表示不连续的一串字符。 所以这里要查找的是不连续的最长子序列，动态规划这里为什么要使用动态规划可以说一下，简单来说动态规划是为了降低时间复杂度的一种算法，申请一个额外空间，来保存每一个步骤的结果，最后从这些结果中找到最优的解。这里有个问题就是：
最长公共子序列长度问题的原理与实现
weixin_62650212的博客
04-11 4625
最长公共子序列（LCS）是一个在计算机科学和生物信息学中常见的问题，它指的是给定两个或多个序列，找出它们共同拥有的最长的子序列。根据这个递推公式，我们可以从左上角开始填充数组 C ，直到右下角得到 C[m,n] ，即为 X 和 Y 的最长公共子序列的长度。动态规划算法的基本思想是利用一个二维数组来存储两个序列之间的最长公共子序列的长度，然后根据递推公式来更新数组的值，最后回溯数组来找出最长公共子序列。例如，“ace” 是 “abcde” 的子序列，但 “aec” 不是 “abcde” 的子序列。
最长公共子序列迭代算法原理
my_live_123
03-15 1835
最长公共子序列(LCS)问题．使用动态规划来给出解决此问题的算法推导过程
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

BQW_

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值