LeetCode-DP算法 | 最长公共子序列和最长公共子串区别

最新推荐文章于 2024-08-23 20:07:50 发布
最新推荐文章于 2024-08-23 20:07:50 发布
阅读量8.6k 收藏 22
点赞数 7
分类专栏： 基本题目

       最长公共子串（Longest Common Substring）与最长公共子序列（Longest Common Subsequence）的区别： 子串要求在原字符串中是连续的，而子序列则只需保持相对顺序一致，并不要求连续。例如X = {a, Q, 1, 1}; Y = {a, 1, 1, d, f}那么，{a, 1, 1}是X和Y的最长公共子序列，但不是它们的最长公共字串。

一、最长公共子序列

具体的算法思想参考以下文章：

http://blog.csdn.net/lisonglisonglisong/article/details/41548557

http://blog.csdn.net/zhongkeli/article/details/8847694

只求最长子序列长度

如果仅仅需要知道最长子序列的长度值，代码如下：

#include <vector>
#include <string>
#include <iostream>
#include <string.h>
#include <sstream>
using namespace std;

//最长公共子串（LCS）
//二维数组veca记录的是两个字符串Xi和Yj的LCS长度
int LCS_length(const string &str1, const string &str2, vector<vector<int> > &veca) {
	int i, j;
	int biggest = 0;
	if (str1 == "" || str2 == "")
		return 0;

	for (i = 0; i <= str1.length(); i++) {
		veca[i][0] = 0;
	}
	for (j = 0; j <= str2.length(); j++) {
		veca[0][j] = 0;
	}
	for (i = 1; i <= str1.length(); i++) {
		for (j = 1; j <= str2.length(); j++) {
			if (str1[i - 1] == str2[j - 1]) {
				veca[i][j] = veca[i - 1][j - 1] + 1;
			}
			else {
				if (veca[i - 1][j] >= veca[i][j - 1])
					veca[i][j] = veca[i - 1][j];
				else
					veca[i][j] = veca[i][j-1];
			}
		}
	}
	return veca[str1.length()][str2.length()];
}

int main() {
	string input;
	getline(cin, input);
        stringstream ss(input);
        string str1, str2;
	ss >> str1;
	ss >> str2;
	//将veca初始化为一个二维数组,其行列值分别为str1和str2的长度加1
	//二维数组veca记录的是两个字符串Xi和Yj的LCS长度
	vector<vector<int> > veca(str1.length() + 1, vector<int>(str2.length() + 1));
	cout << LCS_length(str1, str2, veca) << endl;
	return 0;
}

结果：

动态规划解决LCS问题的时间复杂度为O(mn)，这比简单的递归实现要快多了。空间复杂度是O(mn)，因为使用了一个动态规划表。

要输出一个LCS的内容

和上面的程序比，只需要多一个二维数组记录在遍历中所选择的子问题的最优解即可。如下程序：

//输出最长公共子串（LCS）
//二维数组veca记录的是两个字符串Xi和Yj的LCS长度
int LCS_length(const string &str1, const string &str2, 
	            vector<vector<int> > &veca, vector<vector<int> > &vecb) {
	int i, j;
	int biggest = 0;
	if (str1 == "" || str2 == "")
		return 0;

	for (i = 0; i <= str1.length(); i++) {
		veca[i][0] = 0;
	}
	for (j = 0; j <= str2.length(); j++) {
		veca[0][j] = 0;
	}
	for (i = 1; i <= str1.length(); i++) {
		for (j = 1; j <= str2.length(); j++) {
			//如果Xi-1 == Yj-1，那么最长子序列为veca[i - 1][j - 1] + 1
			//此时将vecb[i][j] = 1表明str1[i-1]是子问题LCS的一个元素
			if (str1[i - 1] == str2[j - 1]) {
				veca[i][j] = veca[i - 1][j - 1] + 1;
				vecb[i][j] = 1;
			}
			else {
				if (veca[i - 1][j] >= veca[i][j - 1]) {
					veca[i][j] = veca[i - 1][j];
					vecb[i][j] = 2;
				}
				else {
					veca[i][j] = veca[i][j-1];
					vecb[i][j] = 3;
				}
			}
		}
	}
	return veca[str1.length()][str2.length()];
}

//该函数用于输出一个LCS的序列
//这里输出的顺序是先向上寻找，再向左寻找
void PrintOneLCS(vector<vector<int> > &vecb, string &str1, int i, int j) {
	if (i == 0 || j == 0)
		return;
	if (vecb[i][j] == 1) {
		PrintOneLCS(vecb, str1, i - 1, j - 1);
		cout << str1[i - 1] << " ";
	}
	else if (vecb[i][j] == 2)
		PrintOneLCS(vecb, str1, i -1, j);
	else
		PrintOneLCS(vecb, str1, i, j - 1);
}

int main() {
	string input;
	getline(cin, input);
	stringstream ss(input);
	string str1, str2;
	ss >> str1;
	ss >> str2;
	//将veca初始化为一个二维数组,其行列值分别为str1和str2的长度加1
	//二维数组veca记录的是两个字符串Xi和Yj的LCS长度
	//二维数组vecb[i][j]记录veca[i][j]时所选择的子问题的最优解
	vector<vector<int> > veca(str1.length() + 1, vector<int>(str2.length() + 1));
	vector<vector<int> > vecb(str1.length() + 1, vector<int>(str2.length() + 1));
	cout << LCS_length(str1, str2, veca, vecb) << endl;
	PrintOneLCS(vecb, str1, str1.length(), str2.length());
	return 0;
}

求一个LCS内容也可以不借助辅助二维数组vecb而是用下面小节的方法，

//该函数用于输出一个LCS的序列，使用下一小节的方法
//这里输出的顺序是先向左寻找，再向上寻找
void PrintOneLCS(string &str1, string &str2, int i, int j, 
	vector<vector<int> > &veca) {
		string lcs_str;
		while (i > 0 && j > 0) {
			if (str1[i - 1] == str2[j - 1]) {
				lcs_str = str1[i - 1] + lcs_str;
				--i;
				--j;
			}
			else {
				//如果左边存在LCS就从左边找否则再从右边找
				if (veca[i - 1][j] >= veca[i][j - 1])
					--i;
				else
					--j;
			}
		}
		cout << lcs_str << endl;
}

如下代码：

要输出所有LCS的内容

两个字符串对应的最长公共子序列不一定唯一，这个程序输出所有的LCS内容。

基本思想是：

具体参考文章：http://blog.csdn.net/lisonglisonglisong/article/details/41596309

代码：

#include <vector>
#include <iomanip>
#include <set>
#include <string>
#include <map>
#include <iostream>
#include <string.h>
#include <sstream>
using namespace std;

set<string> all_lcs; //注意这里要用set去除重复的LCS
//最长公共子串（LCS）
//二维数组veca[i][j]记录的是两个字符串Xi和Yj的LCS长度
int LCS_length(const string &str1, const string &str2, vector<vector<int> > &veca) {
	int i, j;
	int biggest = 0;
	if (str1 == "" || str2 == "")
		return 0;

	for (i = 0; i <= str1.length(); i++) {
		veca[i][0] = 0;
	}
	for (j = 0; j <= str2.length(); j++) {
		veca[0][j] = 0;
	}
	for (i = 1; i <= str1.length(); i++) {
		for (j = 1; j <= str2.length(); j++) {
			if (str1[i - 1] == str2[j - 1]) {
				veca[i][j] = veca[i - 1][j - 1] + 1;
			}
			else {
				if (veca[i - 1][j] >= veca[i][j - 1])
					veca[i][j] = veca[i - 1][j];
				else
					veca[i][j] = veca[i][j-1];
			}
		}
	}
	return veca[str1.length()][str2.length()];
}

//该函数找出所有的LCS的序列，并将其存在vector中
void PrintAllLCS(string &str1, string &str2, int i, int j, 
	             vector<vector<int> > &veca, string lcs_str) {
//注意这里形参lcs_str不可以为引用，这里需要每次调用lcs_str都重新生成一个对象
	while (i > 0 && j > 0) {
		if (str1[i - 1] == str2[j - 1]) {
			lcs_str = str1[i - 1] + lcs_str; //逆向存放
			--i;
			--j;
		}
		else {
			if (veca[i - 1][j] > veca[i][j - 1]) //向左走
				--i;
			else if (veca[i - 1][j] < veca[i][j - 1]) //向上走
				--j;
			else { //此时向上向右均为LCS的元素
				PrintAllLCS(str1, str2, i - 1, j, veca, lcs_str);
				PrintAllLCS(str1, str2, i, j - 1, veca, lcs_str);
				return;
			}
		}
	}
	cout << "   " << lcs_str << endl;
	all_lcs.insert(lcs_str);
}
int main() {
	string input;
	getline(cin, input);
	stringstream ss(input);
	string str1, str2;
	ss >> str1;
	ss >> str2;
	//将veca初始化为一个二维数组,其行列值分别为str1和str2的长度加1
	//二维数组veca记录的是两个字符串Xi和Yj的LCS长度
	vector<vector<int> > veca(str1.length() + 1, vector<int>(str2.length() + 1));
	cout << LCS_length(str1, str2, veca) << endl;

	string lcs_str;
	PrintAllLCS(str1, str2, str1.length(), str2.length(), veca, lcs_str);
	set<string>::iterator iter = all_lcs.begin();
	while (iter != all_lcs.end()) {
		cout << *iter++ << endl;
	}
	return 0;
}

如图所示的两个字符串共有三个LCS。

二、最长公共子串

描述：

计算两个字符串的最大公共子串（Longest Common Substring）的长度，字符不区分大小写。

输入：

输入两个字符串

输出：

输出一个整数

样例输入：

asdfas werasdfaswer

样例输出：

6

这里的最大公共字串要求的字串是连续的。

求字串的方法和求子序列方法类似：

当str1[i] == str2[j]时，子序列长度veca[i][j] = veca[i - 1][j - 1] + 1；只是当str1[i] ！= str2[j]时，veca[i][j]长度要为0，而不是max{veca[i - 1][j], veca[i][j - 1]}。

    #include <vector>  
    #include <string>  
    #include <iostream>  
    #include <string.h>  
    #include <sstream>  
    using namespace std;  
      
    int LCS_length(const string &str1, const string &str2, vector<vector<int> > &veca) {  
        int i, j;  
        int biggest = 0;  
        if (str1 == "" || str2 == "")  
            return 0;  
        for (i = 0; i <= str1.length(); i++) {  
            veca[i].resize(str2.length() + 1, 0);  
        }  
        for (j = 0; j <= str2.length(); j++) {  
            veca[0][j] = 0;  
        }  
        for (i = 1; i <= str1.length(); i++) {  
            for (j = 1; j <= str2.length(); j++) {  
                if (str1[i - 1] == str2[j - 1]) {  
                    veca[i][j] = veca[i - 1][j - 1] + 1;  
                    if (veca[i][j] > biggest)  
                        biggest = veca[i][j];  
                }  
                else  
       //可以看出，求最长子串和求最长子序列差别仅仅在这里
                    veca[i][j] = 0;  
                  
            }  
        }  
        return biggest;  
    }  
      
    int main() {  
        string input;  
        getline(cin, input);  
        stringstream ss(input);  
        string str1;  
        ss >> str1;  
        string str2;  
        ss >> str2;  
        vector<vector<int> > veca(str1.length() + 1);  
        cout << LCS_length(str1, str2, veca) << endl;  
        return 0;  
    }

同样适用求最长子序列的测试数据，得到它们的公共最长子串长度为2，而它们的公共最长子序列长度为4.

三、动态规划的其它题目

1、硬币面值组合问题

http://www.cnblogs.com/python27/archive/2013/09/05/3303721.html

2、最长递增子序列

除了动态规划，该题还有其他解法。

3、数组最大子数组和的最大值

http://www.ahathinking.com/archives/120.html

3、动态规划之钢条分割

4、计算两个字符串的相似度（编程之美）

该文章原理说得比较清楚：点击打开链接

这里是代码：点击打开链接

5、求每一对顶点之间的最短路径：Floyd-Warshall算法

参考：

点滴算法https://blog.csdn.net/column/details/pieces-algorithm.html

https://www.kancloud.cn/digest/pieces-algorithm/163604

努力努力再努力tq
关注
专栏目录
javascript-leetcode面试题解动态规划问题之第1143题最长公共子序列-题解.zip
03-16
本压缩包文件“javascript-leetcode面试题解动态规划问题之第1143题最长公共子序列-题解.zip”包含了关于动态规划解决方案的详细解析，这是一道典型的算法面试题。 动态规划是一种解决复杂问题的有效方法，它通过将...
动态规划：求最长公共子串/最长公共子序列
游戏人生的专栏
05-14 2941
最长公共子序列和最长公共子串区别最长公共子串（Longest Common Substring）与最长公共子序列（Longest Common Subsequence）的区别： 子串要求在原字符串中是连续的，而子序列则只需保持相对顺序一致，并不要求连续。例如X = {a, Q, 1, 1}; Y = {a, 1, 1, d, f}那么，{a, 1, 1}是X和Y的最长公共子序列，但不是它们的最长公...
最长公共子序列和最长公共子串区别
qq_37171273的博客
09-25 853
最长公共子序列和最长公共子串区别        最长公共子串（Longest Common Substring）与最长公共子序列（Longest Common Subsequence）的区别： 子串要求在原字符串中是连续的，而子序列则只需保持相对顺序一致，并不要求连续。例如X = {a, Q, 1, 1}; Y = {a, 1, 1, d, f}那么，{a, 1, 1}是X和Y的最长公共子序列，但
力扣 | 最长公共子序列 | 动态规划 | 最长公共子序列长度、最长公共子序列
最新发布
m0_63997099的博客
08-23 1510
（我们不知道哪个回文中心最好使）
动态规划经典问题 - 求最长公共子串 / 公共子序列
chenyao的博客~
05-24 1783
首先要理解公共子串和公共子序列 公共子串和公共子序列是两个不相同的概念, 公共子串要求字符连续, 公共子序列不要求字符连续。 比如: 字符串"ascde", “axcxdde” 最长公共子串是 “de” , 因为 "de"在两个字符串中都是连续的 最长公共子序列是 “acde”, 不要求连续, 只要满足两个字符串中子序列前后顺序的一致即可 动态规划求最长公共子序列 动态规划的核心是 base case 状态转移方程 自下而上 我们可以通过状态转移表来帮助我们得出状态转移方程 这里我直接说结论: 我们思考
动态规划---求最长公共子序列和最长公共子串（C语言）
热门推荐
CSDN
04-12 1万+
参考：https://blog.csdn.net/someone_and_anyone/article/details/81044153 一、求最长公共子序列 1、问题描述： 从一个给定的串中删去（不一定连续地删去）0个或0个以上的字符，剩下地字符按原来顺序组成的串。例如：“ ”，“a”，“xb”，“aaa”，“bbb”，“xabb”，“xaaabbb”都是串“xaaabbb”的子序列。（例子中的...
最长公共子序列（dp）1
08-03
给定两个字符串text1和text2，目标是找到它们的最长公共子序列，即在不改变字符相对顺序的情况下，两个字符串共有的最长子串。 在动态规划（Dynamic Programming，DP）的解决方案中，我们通常使用二维数组dp来存储...
LeetCode-Solutions:Leetcode Java最佳解决方案
04-04
- 动态规划（DP）：如最长递增子序列、硬币兑换问题等。 4. **Java 优化技巧**： - 内存管理：了解对象的生命周期和垃圾回收机制，避免内存泄漏。 - 性能优化：减少不必要的计算，合理使用数据结构，避免冗余...
leetcode表现最好的时间段-DP-Interviews:DP-面试
06-30
leetcode 表现最好的时间段动态规划 ...同样，您也可以使用最长公共子序列技术。 你需要在str和str.reverse()上做一个 LCS 然后str.length - LCS(str, str.reverse())会给你同样的答案。 高级字符串D
leetcode-tag-dynamic programming
04-29
2. 最长公共子序列（LCS）：寻找两个字符串的最长子序列，子序列不必连续，但必须保持原有顺序。 3. 最短路径问题：例如Dijkstra算法或Floyd-Warshall算法的变种，寻找图中两点之间的最短路径。 4. 数学问题：如...
深刻理解最长公共子串、最长公共子序列（应该比较全面）
11-21 2958
这里写自定义目录标题 理论知识： 推荐参考该博文：java实现字符串匹配问题之求两个字符串的最大公共子串 当然这篇也一样，看个人理解：求两个字符串的最长公共子串 图形理解： ...
最长公共子串与最长公共子序列
daxunniao6402的博客
03-30 162
两者的区别： 　　最长公共子串（Longest Common Substirng）和最长公共子序列（Longest Common Subsequence，LCS）的区别为：子串是串的一个连续的部分，子序列则是从不改变序列的顺序，而从序列中去掉任意的元素而获得新的序列；也就是说，子串中字符的位置必须是连续的，子序列则可以不必连续。 转载于:https://www.cnblogs.com...
动态规划-最长公共子序列
God is Coder
08-15 499
 最长公共子序列和最长公共子串区别        最长公共子串（Longest Common Substring）与最长公共子序列（Longest Common Subsequence）的区别： 子串要求在原字符串中是连续的，而子序列则只需保持相对顺序一致，并不要求连续。例如X = {a, Q, 1, 1}; Y = {a, 1, 1, d, f}那么，{a, 1, 1}是X和Y的最长
公共子序列与公共子串问题
weixin_34416649的博客
08-30 165
1、公共子序列问题 网上有很多关于公共子序列问题，说的大同小异，看了很多不明白，很多都是晦涩难懂，这里分享一个连接，个人觉得讲述的比较明白，易懂。 http://blog.csdn.net/v_july_v/article/details/6695482 我这里也简单的把自己的理解说一下，求公共子序列问题是一个非常常见的问题，最差的方法就是暴力匹配，暴力匹配算法第一步求去短字符串的所有序列组...
最长公共子序列与最长公共子串区别
超级码力
08-15 423
最长公共子序列与最长公共子串区别 假设s1=“abaaca”, s2=“acaaba”。 最长公共子序列是s1和s2的不连续的最大公共子集。例如，s1和s2的最长公共子序列是[‘a’,’a’,’a’,’a’] 最长公共子串是s1和s2中连续的最长公共子串。例如，s1和s2的最长公共子串是“aca”和“aba” 最长公共子序列c++实现 两个实现差不多，这里均使用动态规划实现。实现一是最普通的动态规划，实现二则进行了状态压缩。 实现一：无状态压缩 int lcs_normal(string s1, str
经典算法题每日演练——第四题 最长公共子序列
weixin_33896069的博客
11-11 1256
  一： 作用        最长公共子序列的问题常用于解决字符串的相似度，是一个非常实用的算法，作为码农，此算法是我们的必备基本功。 二：概念      举个例子，cnblogs这个字符串中子序列有多少个呢？很显然有27个，比如其中的cb,cgs等等都是其子序列，我们可以看出 子序列不见得一定是连续的，连续的那是子串。      我想大家已经了解了子序列的概念，那现在可以延伸到两个字...
最长公共子串和最长公共子序列
heatrain的博客
09-18 121
主要区别：子串必须要连续，子序列不需要 相关符号：字符串 X 与 Y。Xi表示X在第i位上的字符(在这里X的第一位表示为1而不是0)，Yj同理。 c[i][j]表示字符串X1..i与Y1..j的最长公共子序列或最长公共子串的长度 最长公共子序列 def longest_seq(s1, s2): m, n = len(s1), len(s2) dp = [['' for _ in range(n+1)] for _ in range(m+1)] for i in ran..
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值