最长公共子串计算C++

最新推荐文章于 2024-09-20 10:50:16 发布
最新推荐文章于 2024-09-20 10:50:16 发布
阅读量2.2k 收藏 15
点赞数 2
分类专栏： 面试经验分享 文章标签： 最长公共子串

公共字串计算（最长公共子串/序列）C++

描述

题目标题：
计算两个字符串的最大公共字串的长度，字符不区分大小写

输入

输入两个字符串

输出

输出一个整数

样例输入

asdfas werasdfaswer

样例输出

6

思路

暴力求解
此题用cin即可

代码

#include <iostream>
#include <string>
using namespace std;
int Maxsubstr(string a,string b)
{
    unsigned int start1,start2;
    int count=0,Max=0;
    for(unsigned int i=0; a[i]!='\0'; i++)
    {
        for(unsigned int j=0; b[j]!='\0'; j++)
        {
            start1=i;
            start2=j;
            while(a[start1]==b[start2] && start1<a.length() && start2<b.length())
            {
                start1++;
                start2++;
                count++;
            }
            if(count>Max)
            {
                Max=count;
            }
            count=0;
        }
    }
    return Max;
}

int main()
{
    string str1,str2;
    cin>>str1;
    cin>>str2;
    //不区分大小写
    for (unsigned int i=0; i<str1.length(); i++)
    {
        str1[i]=tolower(str1[i]);
    }
    for (unsigned int i=0; i<str2.length(); i++)
    {
        str2[i]=tolower(str2[i]);
    }
    cout<<Maxsubstr(str1,str2)<<endl;
}

这里写图片描述

题目

描述

查找两个字符串a,b中的最长公共子串。
详细描述：
查找两个字符串a,b中的最长公共子串。

输入

输入两个字符串

输出

返回重复出现的字符

样例输入

abcdefghijklmnop
abcsafjklmnopqrstuvw

样例输出

jklmnop

思路

暴力求解

代码

#include <iostream>
#include <string>
using namespace std;
int Maxsubstr(string a,string b,string *&s)
{
    unsigned int start,start1,start2;
    int count=0,Max=0;
    for(unsigned int i=0; a[i]!='\0'; i++)
    {
        for(unsigned int j=0; b[j]!='\0'; j++)
        {
            start1=i;
            start2=j;
            while(a[start1]==b[start2] && start1<a.length() && start2<b.length())
            {
                start1++;
                start2++;
                count++;
            }
            if(count>Max)
            {
                start = i;
                Max = count;
            }
            count=0;
        }
    }
    //保存字符串
    s=new string[Max+1];
    for(int i=0; i<Max; i++)
    {
        s[i]=a[i+start];
    }
    s[Max]='\0';
    return Max;
}

int main()
{
    string str1,str2,*str;    
    cin>>str1>>str2;
    //此题输入-------------
    //getline(cin,str1);
    //getline(cin,str2);
    int length = Maxsubstr(str1,str2,str);
    for(int i=0; i<length; i++)
    {
        cout<<str[i];
    }
    cout<<endl;
    return 0;
}
这里写图片描述
这里写图片描述

如果你看到这里觉得暴力方法太low

Low。。。。

哎，那就聊聊动态规划版的经典问题《最长公共子串（序列）》

子串是连续的，子序列可以是不连续的。

状态转移方程：

符号约定，C1是S1的最右侧字符，C2是S2的最右侧字符，S1‘是从S1中去除C1的部分，S2’是从S2中去除C2的部分。

LCS(S1,S2)等于下列3项的最大者：

（1）LCS（S1，S2′′）

（2）LCS（S1′′，S2）

（3）LCS（S1′′）+C1 —如果C1等于C2；

边界终止条件：如果S1和S2都是空串，则结果也是空串。

下面我们同样要构建一个矩阵来存储动态规划过程中子问题的解。这个矩阵中的每个数字代表了该行和该列之前的LCS的长度。与上面刚刚分析出的状态转移议程相对应，矩阵中每个格子里的数字应该这么填，它等于以下3项的最大值：

（1）上面一个格子里的数字

（2）左边一个格子里的数字

（3）左上角那个格子里的数字（如果 C1不等于C2）； 左上角那个格子里的数字+1（ 如果C1等于C2）

#include<iostream>
#include<cstring>
#include <vector>

using namespace std;

void SubSequence(vector<vector<string>> &flag,string str1, string str2,int i,int j);
void display(int *result,string str1,string str2);

void initialVector(vector<vector<string>> &vectorAll,int len)
{
    for(int i=0; i<len; ++i)
    {
        vector<string> temp;
        vectorAll.push_back(temp);
    }
}

int lcs_string(string str1, string str2)
{
    int len1 = str1.length();
    int len2 = str2.length();
    int result = 0;     //记录最长公共子串长度
    int c[len1+1][len2+1] ;
    int endPos = -1;
    for (int i = 0; i <= len1; i++)
    {
        for( int j = 0; j <= len2; j++)
        {
            if(i == 0 || j == 0)
            {
                c[i][j] = 0;
            }
            else if (str1.at(i-1) == str2.at(j-1))
            {
                c[i][j] = c[i-1][j-1] + 1;
                result = max(c[i][j], result);
                if(result==c[i][j])  endPos = i;//记录最后一个点的位置
            }
            else
            {
                c[i][j] = 0;//重新计数
            }
        }
    }
    //print result
    string str="";
    if(endPos<=len1)
    {
        str = str1.substr(endPos-result,result);
    }
    else
    {
        str = str2.substr(endPos-result,result);
    }
    cout<<"\n\nLongest Common Substring : "<<str<<endl;
    return result;
}
//对于最长公共子序列，只是在最后一个else里面放的是前两步的最大值
int lcs_squence(string str1, string str2)
{
    int len1 = str1.length();
    int len2 = str2.length();
    int c[len1+1][len2+1];
    vector<vector<string>> flag;
    initialVector(flag,len1+1);
    for (int i = 0; i <= len1; i++)
    {
        for( int j = 0; j <= len2; j++)
        {
            if(i == 0 || j == 0)
            {
                c[i][j] = 0;
                flag[i].push_back("NULL");
            }
            else if (str1.at(i-1) == str2.at(j-1))
            {
                c[i][j] = c[i-1][j-1] + 1;
                flag[i].push_back("left_up");

            }
            else if(c[i - 1][j]>=c[i][j - 1])
            {
                c[i][j]=c[i - 1][j];
                flag[i].push_back("left");
            }
            else
            {
                c[i][j] = c[i][j - 1];
                flag[i].push_back("up") ;
            }
        }

    }
    //display(&c[0][0],str1,str2);  //输出数组
    SubSequence(flag,str1,str2,str1.length(),str2.length());
    //cout<<c[len1][len2]<<endl;
    return c[len1][len2];
}

void display(int *result,string str1,string str2)
{
    int len1 = str1.length();
    int len2 = str2.length();
    //输出表头
    for(int i=0; i<=len2; ++i)
    {
        cout<<"\t"<<str2[i];
    }
    cout<<endl;
    //输出数组
    for(int i=0; i<=len1; ++i)
    {
        cout<<str1[i]<<"\t";
        for(int j=0; j<=len2; ++j)
        {
            cout<<*result<<"\t";
            result++;
        }
        cout<<endl;
    }

}
//按照方向查找
void SubSequence(vector<vector<string>> &flag,string str1, string str2,int i,int j)
{
    if (i == 0 || j == 0)
        return;

    if (flag.at(i).at(j) == "left_up")
    {
        cout<<str2[j - 1]<<" ("<< i - 1<<" , "<< j - 1<<")"<<endl;
        //左前方
        SubSequence(flag,str1,str2,i - 1, j - 1);
    }
    else
    {
        if (flag.at(i).at(j) == "up")
        {
            SubSequence(flag,str1,str2,i, j - 1);
        }
        else
        {
            SubSequence(flag,str1,str2,i - 1, j);
        }
    }
}

int main()
{
    string X = "";
    string Y = "";
    //输入
    getline(cin,X);
    getline(cin,Y);
    cout<<"\nFirst string:\n"<<X<<endl;
    cout<<"\nSecond string:\n"<<Y<<endl;
    cout << "Length of Longest Common Substring is " << lcs_string(X, Y)<<endl;
    cout << "Length of Longest Common Subsequence is " << lcs_squence(X, Y)<<endl;
    return 0;
}

这里写图片描述

参考引用

传送门 ： 最长公共子序列

传送门 ： 最长公共子序列（LCS）C++实现

传送门 ： 最长公共子序列与最长公共子串

传送门 ： 最长公共子序列。。

传送门 ： 最长公共子序列。。大杂烩

C++——最长公共子串
一抹阳光的博客
05-09 3952
对于两个字符串A和B，A的前i位和B的前j位的最大公共子序列必然是所求解的一部分，设dp[i][j]为串A前i位和B串前j位的最长公共子序列的长度，则所求答案为dp[n][m]，其中n，m分别为字符串A和B的长度，若A[i]=B[j]，则该元素可以作为之前构造的公共子序列的下一位元素，dp[i][j]=dp[i-1][j-1]+1，同时判断当前记录的最长子串的结果maxlen与dp[i][j]的大小，若是大于当前的最大值maxlen，则更新maxlen的值，同时记录索引位置index。直到所有遍历...
公共字串计算（最长公共子串/序列）C++
人间词话·CODE
01-02 5601
借着写题，来点总结 题目标题： 计算两个字符串的最大公共字串的长度，字符不区分大小写 输入 输入两个字符串 输出 输出一个整数 样例输入 asdfas werasdfaswer 样例输出 6
【算法】最长公共子序列（C/C++）
最新发布
大三计算机在读，分享我的算法之路
09-20 3765
简称（LCS），是动态规划里面里面的基础算法它的所解决的问题是，在两个序列中找到一个序列，使得它既是第一个序列的子序列，也是第二个序列的子序列，并且该序列长度最长。由下图中两个序列，我们可以看出来最长公共子序列为[s c r g]。我们来举个“”，比如序列A为“abcdef”，序列B为“bcef”，那么它的最长公共子序列为序列B，即：“bcef”，注意最长公共子序列不用保证每一个字符必须连续。那么我们一般的暴力做法是什么呢？
最长公共子序列和最长公共子串——C++
qq_38236355的博客
10-06 1204
一、给定两个字符串S1和S2，求两个字符串的最长公共子序列的长度。 输入样例 ABCD AEBD 输出样例 3 解释 S1和S2的最长公共子序列为ABD，长度为3 思路 动态规划 LCS(m,n)表示S1[0…m]和S2[0…n]的最长公共子序列的长度 S1[m] == S2[n]: LCS(m, n) = 1 + LCS(m - 1, n - 1)； S1[m] != S2[n]: LCS(m, n) = max(LCS(m - 1, n), LCS(m, n - 1))。 #inc
【算法】C++ 最长公共子串长度
weixin_44566432的博客
03-19 1590
最长公共子串长度 串 A 以 i 为结尾和串 B 以 j 为结尾的最长公共子序列长度maxlen[i][j]=max（maxlen[i][j-1]，maxlen[i-1][j]） 当A的第i-1字符个和B的第j-1个字符一样时maxlen[i][j] = maxlen[i-1][j-1] + 1; #include <stdio.h> #include <string.h> #define N 256 int f(const char* s1, const c...
c++最长公共子序列和最长公共子串
每日提升一点点
04-12 1048
解释： 最长公共子序列是指：找出两个字符串中的共同子序列，字符可以不连续。比如：s1="abcd",s2="abcefd"，则最长子序列为abcd(其中d与abc不连续但是在abc的后面顺序排列)。 公式为：（如图） 最长公共子串为更为严格的公共子序列。字符必须连续。比如：s1="abcd",s2="abcefd"，则最长子串为abc。 公式如图： 代码一：（最长公共子序列）...
C++数据结构——最长公共子串
weixin_44546342的博客
05-02 2483
一个序列中去掉若干（也可以不去掉）元素剩下的部分称为其子序列。对于给定的序列X = <x1，x2，…，xm>，称序列Z = <z1，z2，…，zk>为X的一个子序列，仅当在X中存在一个递增序号序列<i1，i2，…，ik>，对所有的j（1，2，…，k）满足 xij​= z j。例如，Z = <a，b，f，c>是X = <a，b，c，f，b，c> 的一个子序列，X中相应的序号序列为 <1，2，4，6>。要求输入两个字符串，求它们的最长公共.
C++求两个字符串的最长公共子串
泓源的博客
04-02 7427
文字解释过于繁琐直接上例子： const char* s1 = “ADOBE”; const char* s2 = “ABE”; 对于这两个字符串，先标记相同字符的在矩阵中为1否则为0： A D O B E A 1 0 0 0 0 B 0 0 0 1 0 E 0 0 0 0 1 那么公共子串即为对角线为1的，比如‘A’、‘BE’，只需在其中找到最长的1的对角线即可，这...
【C++】求两个字符串的最长公共子串
李嘉佑的博客
07-21 2287
【C++】求两个字符串的最长公共子串
利用C++实现最长公共子序列与最长公共子串
09-01
总结来说，C++实现最长公共子序列与最长公共子串的关键在于理解和应用动态规划的思想，通过建立二维数组来存储中间状态，避免重复计算，从而提高算法效率。这两个问题的解决方案都可以有效地解决字符串匹配中的问题...
C++实现最长公共子串算法(附完整源码)
uote_e的博客
08-30 586
然后，使用后缀数组来处理新的字符串，并找到在A和B中都出现过的子串集合。最后，我们可以在这些子串中找到最长的那一个，即为最长公共子串。后缀数组的主要思想是将一个字符串的所有后缀按照字典序排序，然后将排名和后缀两个信息保存在同一个数组中，以便进行查询等操作。下面是基于后缀数组实现的最长公共子串算法的C++源代码。最长公共子串是指在两个或多个字符串中出现的相同子串中最长的那一个。这是一个经典的字符串算法问题，有很多种不同的实现方法。本文将介绍一种使用后缀数组的算法实现，并提供相应的C++源代码。
NC127 最长公共子串(c++)
qq_36421001的博客
03-09 437
class Solution { public: /** * longest common substring * @param str1 string字符串 the string * @param str2 string字符串 the string * @return string字符串 */ string LCS(string str1, string str2) { // write code here ...
最长公共子串的C++实现代码
冒大烟的羊肉串的专栏
09-03 1547
算法思想 求字符串str1,str2的最长公共子串的长度。 定义二元函数函数f(m,n)：分别以str1[m],str2[n]结尾的连续公共子串的长度 而对于f(m+1,n+1) 有以下两种情况 1.str1[m+1] != str2[n+1],则有f(m+1,n+1
C++ 关于最长公共子串问题
Rioer的博客
03-09 1028
/* 题目描述 Description 人类基因组计划在人类基因中截获了两个DNA序列,序列A和B,规定两个序列所隐藏的遗传信息就是两者的最长公共子串(注意,这里的子串是指连续的,比如说ABCDEFG中ABC是ABCDEFG的子串,而ABD或者ABE都不是ABCDEFG的子串),现在,你需要找出其中所有的遗传信息（即最长公共子串）以及遗传信息的个数。输入描述 Input Descriptio
C++最长公共子序列和最长公共子串
weixin_44501989的博客
09-09 280
两个字符串的最长公共子串与最长公共子序列的区别： 最长公共子串要求在原字符串中是连续的，而子序列只需要保持相对顺序一致，并不要求连续。 这里放自己写的代码 最长公共子序列 class Solution { public: int longestCommonSubsequence(string text1, string text2) { int len1 =text1.size(),len2 =text2.size(); vector<vector&l
C++13. 最长公共子串
qjsssss的博客
12-04 1126
最长公共子串 【问题描述】 编写一个程序，对输入的字符串s和t，求其最长的公共子字符串。 【输入形式】 从屏幕分行读入串s和t。s和t由任意字符构成，长度都不超50个字符。输入数据确保只有唯一的最长公共子串。如果没有公共子串，打印No Answer 【输出形式】 在单独行上输出串s和串t的最长公共子串，在结尾输出一个回车符。 算法提示：用一个int型的计数器记录当前匹配长度，用一个字符数组记录当前匹配子串，如果存在更长子串，则进行相应替换。 【样例说明】 假设从屏幕输入以下内容： aabcdababce.
两个字符串中最长公共子串——C++实现
ling08140814的博客
05-17 5285
程序分析：从较短的字符串着手，对它的子串从长到短，依次与较长的字符串进行匹配。 C++代码： #define _CRT_SECURE_NO_WARNINGS #include<iostream> using namespace std; char* GetCommonString(char *str1, char *str2) { if (str1 == NULL || str2 == NULL) { return NULL; } char *longstr, *shortstr
最长公共子串（C++牛客网）
coolsunxu的博客
04-08 479
最长公共子串（C++牛客网）
最长公共子串C++代码
07-24
以下一个使用动态规划算法求最长公共子串（Longest Common Substring）的C++代码示例： ```cpp #include <iostream> #include <string> #include <vector> using namespace std; string LongestCommonSubstring(string s1, string s2) { int m = s1.length(); int n = s2.length(); // 创建二维动态规划数组 vector<vector<int>> dp(m + 1, vector<int>(n + 1, 0)); int maxLength = 0; // 最长公共子串的长度 int endIndex = 0; // 最长公共子串在s1中的结束索引 // 动态规划计算公共子串长度 for (int i = 1; i <= m; i++) { for (int j = 1; j <= n; j++) { if (s1[i - 1] == s2[j - 1]) { dp[i][j] = dp[i - 1][j - 1] + 1; if (dp[i][j] > maxLength) { maxLength = dp[i][j]; endIndex = i - 1; } } } } // 提取最长公共子串 string longestSubstring = s1.substr(endIndex - maxLength + 1, maxLength); return longestSubstring; } int main() { string s1, s2; cout << "请输入字符串s1："; cin >> s1; cout << "请输入字符串s2："; cin >> s2; string longestSubstring = LongestCommonSubstring(s1, s2); cout << "最长公共子串为：" << longestSubstring << endl; return 0; } ``` 在示例代码中，我们使用动态规划的思想来解决最长公共子串的问题。我们创建一个二维动态规划数组`dp`，其中`dp[i][j]`表示以`s1[i-1]`和`s2[j-1]`为结尾的最长公共子串的长度。然后，我们遍历字符串`s1`和`s2`的所有字符，如果当前字符相等，则将`dp[i][j]`更新为`dp[i-1][j-1] + 1`，同时记录最长公共子串的长度和在`s1`中的结束索引。最后，我们通过提取最长公共子串的方式得到最终的结果。 请注意，以上代码仅考虑了求解最长公共子串的长度和提取最长公共子串，如果需要其他操作（如输出所有最长公共子串），可能需要进行适当的修改。 希望对你有帮助！如果你有任何问题，请随时提问。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值