子序列、子串问题

最新推荐文章于 2024-07-08 08:41:57 发布
最新推荐文章于 2024-07-08 08:41:57 发布
阅读量631 收藏
点赞数
CC 4.0 BY-SA版权
分类专栏： 算法 C++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/pymqq/article/details/14106247
本文介绍了一种求解最长公共子序列（LCS）问题的算法实现，包括打印任意一个公共子序列及所有公共子序列的方法。通过动态规划确定两个字符串间的最长公共子序列，并提供代码实现。 
#include<iostream>
#include <vector>
using namespace std;

//enum decreaseDire {kInit = 0,kLeft = 1,kUp = 2,kLeftUp = 4};
enum decreaseDire {kInit = 0,kLeft = 1,kUp = 2,kLeftUp = 4};

//打印任意一个公共子序列
void LCS_Print(int **LCS_direction,const char* pStr1,const char* pStr2,size_t row,size_t col)
{
	if(!pStr1 || !pStr2)
		return ;
	size_t length1 = strlen(pStr1);
	size_t length2 = strlen(pStr2);
	if(length1 == 0 || length2 == 0)
		return ;
	if(row>=length1 || col>=length2 || row<0 || col<0)
		return ;
	if(LCS_direction[row][col] == kLeftUp){
		LCS_Print(LCS_direction,pStr1,pStr2,row-1,col-1);	printf("%c",pStr1[row]);
	}else if(LCS_direction[row][col] == kLeft){
		LCS_Print(LCS_direction,pStr1,pStr2,row,col-1);
	}else if(LCS_direction[row][col] == kUp){
		LCS_Print(LCS_direction,pStr1,pStr2,row-1,col);
	}
	return ;
}
//打印任意所有公共子序列
void LCS_Print_AllSeq(int **LCS_direction,const char* pStr1,const char* pStr2,size_t row,size_t col,char *result,int start)
{
	if(!pStr1 || !pStr2)
		return ;
	size_t length1 = strlen(pStr1);
	size_t length2 = strlen(pStr2);
	if(length1 == 0 || length2 == 0)
		return ;
	if(row>=length1 || col>=length2 || row<0 || col<0){
		printf("%s\n",result+start+1);
		return ;
	}
	switch(LCS_direction[row][col]){
		case kLeft:
			LCS_Print_AllSeq(LCS_direction,pStr1,pStr2,row,col-1,result,start);
			break;
		case kUp:
			LCS_Print_AllSeq(LCS_direction,pStr1,pStr2,row-1,col,result,start);
			break;
		case kLeftUp:
			result[start] = pStr1[row];
			LCS_Print_AllSeq(LCS_direction,pStr1,pStr2,row-1,col-1,result,start-1);	//printf("%c",pStr1[row]);
			break;
		case kLeft+kUp:
			LCS_Print_AllSeq(LCS_direction,pStr1,pStr2,row,col-1,result,start);
			LCS_Print_AllSeq(LCS_direction,pStr1,pStr2,row-1,col,result,start);
			break;
		case kLeft+kLeftUp:
			LCS_Print_AllSeq(LCS_direction,pStr1,pStr2,row,col-1,result,start);
			LCS_Print_AllSeq(LCS_direction,pStr1,pStr2,row-1,col-1,result,start-1);	//printf("%c",pStr1[row]);
			break;
		case kUp+kLeftUp:
			LCS_Print_AllSeq(LCS_direction,pStr1,pStr2,row-1,col,result,start);
			LCS_Print_AllSeq(LCS_direction,pStr1,pStr2,row-1,col-1,result,start-1);	//printf("%c",pStr1[row]);
			break;
		case kLeft+kUp+kLeftUp:
			LCS_Print_AllSeq(LCS_direction,pStr1,pStr2,row,col-1,result,start);
			LCS_Print_AllSeq(LCS_direction,pStr1,pStr2,row-1,col,result,start);
			LCS_Print_AllSeq(LCS_direction,pStr1,pStr2,row-1,col-1,result,start-1);	//printf("%c",pStr1[row]);
			break;
	}
// 	if(LCS_direction[row][col] == kLeftUp){
// 		LCS_Print(LCS_direction,pStr1,pStr2,row-1,col-1);	printf("%c",pStr1[row]);
// 	}
// 	if(LCS_direction[row][col] == kLeft){
// 		LCS_Print(LCS_direction,pStr1,pStr2,row,col-1);
// 	}
// 	if(LCS_direction[row][col] == kUp){
// 		LCS_Print(LCS_direction,pStr1,pStr2,row-1,col);
// 	}
}
//subsequence
int LCS(const char* pStr1,const char* pStr2)
{
	if(!pStr1 || !pStr2)
		return 0;
	size_t length1 = strlen(pStr1);
	size_t length2 = strlen(pStr2);
	if(length1 == 0 || length2 == 0)
		return 0;

	int **LCS_length,**LCS_direction;
	size_t i,j;
	LCS_length = new int*[length1];	LCS_direction = new int*[length1];
	for(i=0;i<length1;i++){
		LCS_length[i] = new int[length2];	LCS_direction[i] = new int[length2];
	}
	for(i=0;i<length1;i++){
		for(j=0;j<length2;j++){
			LCS_length[i][j] = 0;	LCS_direction[i][j] = kInit;
		}
	}
	for(i=0;i<length1;i++){
		for(j=0;j<length2;j++){
			if(i==0 || j==0){
				if(pStr1[i] == pStr2[j]){
					LCS_length[i][j] = 1;					LCS_direction[i][j] = kLeftUp;
				}
			}else if(pStr1[i] == pStr2[j]){
				LCS_length[i][j] = LCS_length[i-1][j-1]+1;	LCS_direction[i][j] = kLeftUp;
			}else if(LCS_length[i-1][j] >= LCS_length[i][j-1]){
				LCS_length[i][j] = LCS_length[i-1][j];		LCS_direction[i][j] = kUp;
			}else{
				LCS_length[i][j] = LCS_length[i][j-1];		LCS_direction[i][j] = kLeft;
			}
			//printf("%2d ",LCS_length[i][j]);
			printf("%2d ",LCS_direction[i][j]);
		}
		printf("\n");
	}
	LCS_Print(LCS_direction,pStr1,pStr2,length1-1,length2-1);
	return LCS_length[length1-1][length2-1];
}
//AllSeq
int LCS_AllSeq(const char* pStr1,const char* pStr2)
{
	if(!pStr1 || !pStr2)
		return 0;
	size_t length1 = strlen(pStr1);
	size_t length2 = strlen(pStr2);
	if(length1 == 0 || length2 == 0)
		return 0;

	int **LCS_length,**LCS_direction;
	size_t i,j;
	LCS_length = new int*[length1];	LCS_direction = new int*[length1];
	for(i=0;i<length1;i++){
		LCS_length[i] = new int[length2];	LCS_direction[i] = new int[length2];
	}
	for(i=0;i<length1;i++){
		for(j=0;j<length2;j++){
			LCS_length[i][j] = 0;	LCS_direction[i][j] = kInit;
		}
	}
	for(i=0;i<length1;i++){
		for(j=0;j<length2;j++){
			if(i==0 && j==0){
				if(pStr1[i] == pStr2[j]){
					LCS_length[i][j] = 1;					LCS_direction[i][j] += kLeftUp;
				}
			}else if(i==0 || j==0){
				if(pStr1[i] == pStr2[j]){
					LCS_length[i][j] = 1;					LCS_direction[i][j] += kLeftUp;
				}
				if(i==0){
					if(LCS_length[i][j-1] == 1){
						LCS_length[i][j] = 1;
						LCS_direction[i][j] += kLeft;
					}
				}else{
					if(LCS_length[i-1][j] == 1){
						LCS_length[i][j] = 1;
						LCS_direction[i][j] += kUp;
					}
				}
			}
			if(i!=0 && j!=0){
				if(pStr1[i] == pStr2[j]){
					LCS_length[i][j] = LCS_length[i-1][j-1]+1;	LCS_direction[i][j] += kLeftUp;
					if(LCS_length[i-1][j] == LCS_length[i][j]){
						LCS_direction[i][j] += kUp;
					}
					if(LCS_length[i][j-1] == LCS_length[i][j]){
						LCS_direction[i][j] += kLeft;
					}
				}else{
					if(LCS_length[i-1][j] == LCS_length[i][j-1]){
						LCS_length[i][j] = LCS_length[i-1][j];
						LCS_direction[i][j] += kUp;
						LCS_direction[i][j] += kLeft;						
					}else if(LCS_length[i-1][j] > LCS_length[i][j-1]){
						LCS_length[i][j] = LCS_length[i-1][j];
						LCS_direction[i][j] += kUp;
					}else{
						LCS_length[i][j] = LCS_length[i][j-1];
						LCS_direction[i][j] += kLeft;			
					}
				}
			}
			printf("%2d ",LCS_direction[i][j]);
			//printf("%2d ",LCS_length[i][j]);
		}
		printf("\n");
	}
	char *result = new char[length1+1];
	result[length1] = '\0';
	LCS_Print_AllSeq(LCS_direction,pStr1,pStr2,length1-1,length2-1,result,length1-1);
	return LCS_length[length1-1][length2-1];
}
//substring
int LCString(const char* pStr1,const char* pStr2)
{
	if(!pStr1 || !pStr2)
		return 0;
	size_t length1 = strlen(pStr1);
	size_t length2 = strlen(pStr2);
	if(length1 == 0 || length2 == 0)
		return 0;

	int **LCS_length,**LCS_direction;
	size_t i,j;
	LCS_length = new int*[length1];	LCS_direction = new int*[length1];
	for(i=0;i<length1;i++){
		LCS_length[i] = new int[length2];	LCS_direction[i] = new int[length2];
	}
	for(i=0;i<length1;i++){
		for(j=0;j<length2;j++){
			LCS_length[i][j] = 0;	LCS_direction[i][j] = kInit;
		}
	}
	int maxLen = 0;int maxI = 0,maxJ = 0;
	for(i=0;i<length1;i++){
		for(j=0;j<length2;j++){
			if(i==0 || j==0){
				if(pStr1[i] == pStr2[j]){
					LCS_length[i][j] = 1;					LCS_direction[i][j] = kLeftUp;
				}
			}else if(pStr1[i] == pStr2[j]){
				if(LCS_direction[i-1][j-1] = kLeftUp){
					LCS_length[i][j] = LCS_length[i-1][j-1]+1;	LCS_direction[i][j] = kLeftUp;
				}
				else{
					LCS_length[i][j] = 1;						LCS_direction[i][j] = kLeftUp;
				}
			}
			if(LCS_length[i][j] > maxLen){
				maxLen = LCS_length[i][j];
				maxI = i;	maxJ = j;
			}
		}
	}
	//LCS_Print(LCS_direction,pStr1,pStr2,length1-1,length2-1);
	//return LCS_length[length1-1][length2-1];
	LCS_Print(LCS_direction,pStr1,pStr2,maxI,maxJ);
	return maxLen;
}

int main()
{
	char Str1[] = "BDCABA",Str2[] = "ABCBDAB";
	//char Str1[] = "dhajhfakdfjkahfahakjhfjahyfhgqioqurjdnachhzjjckaghda",Str2[] = "qyuiaudhajndjahdfjajdalkfdyi8qyahjkdhajhdfahfjhasfka";
	//char Str1[] = "dhajhfakdfjkahfahakjhfa",Str2[] = "qyuiaudhajndjahdhasfka";
	int Len;
	//Len = LCS(Str1,Str2);			//子串
	//Len = LCS_AllSeq(Str1,Str2);	//所有子串
	Len = LCString(Str1,Str2);		//子序列
	cout<<endl<<Len<<endl;
	return 0;
}
子串和子序列问题-动态规划向
weixin_45532984的博客
10-23 2185
有关于子序列和子串的问题是字符串或者数组经常会遇到的问题，一般我们经常使用多指针，滑动窗口，动态规划的方式去解决，而本篇重点关注能用动态规划解决或者说明显使用动态规划解决的子串问题和子序列问题。子串是字符串中的由连续字符组成的一个序列，重点在于连续。例如，"1AB2345CD"，那么"1AB23"，"5CD"都是相应的子串，而"12345CD"不是，已经不是连续的状态。字符串的一个子序列是原始字符串删除一些（也可以不删除）字符而不改变剩余字符相对位置形成的新字符串，那么很明显，子序列和子串最大的区别就是可
最长上升子序列/子串和最长公共子序列/子串
_zhy_cq
07-17 1168
文章目录子序列（不连续）最长上升子序列（暴力回溯）（动规）（动规 + 二分 + 贪心）（动规 + 二分 + 贪心）化简版最长公共子序列（动规）（动规）子序列（连续）最长连续上升子序列（动规）（双指针）最长公共子数组 （动规）（动规 一维数组优化）（滑动窗口 待更新） 子序列（不连续） <span id = “最长上升子序列">最长上升子序列 LIS（longest increasing subsequence）是最经典的动态规划题目之一，因为它的递推公式很有条理，可以很清楚的告诉我们什么状态可以
子串和子序列
sinoai
06-22 1427
算法题1. 最大子串和 1. 最大子串和   输入整数序列，输出所有连续子串中和最大的那个子串的和。   示例输入：[1,2,3,−4,5,−6][1, 2, 3, -4, 5, -6][1,2,3,−4,5,−6]，输出777。 // 1.暴力法：遍历所有子串。 template<size_t N> int maxSubStr1(int (&arr)[N]) { int Max = INT_MIN; for (int i = 0; i < N; i++) { int SU
子序列与子串问题
qq_45928272的博客
08-16 581
最长公共子序列 class Solution { public: int longestCommonSubsequence(string text1, string text2) { vector<vector<int>> dp(text1.size()+1,vector<int>(text2.size()+1,0)); for(int i=1;i<=text1.size();i++) {
子序列与子串的问题
weixin_30511039的博客
07-09 223
LCS 转载于:https://www.cnblogs.com/shnuxiaoan/p/11159287.html
求解最大子序列、最长递增子序列、最长公共子串、最长公共子序列
12-16
求解最大子序列、最长递增子序列、最长公共子串、最长公共子序列. http://blog.youkuaiyun.com/ssuchange/article/details/17341693
【动态规划】最长子串问题汇总（四）最长公共上升子序列
weixin_57706322的博客
02-23 2011
在练习算法的过程中，发现各种子序列问题容易混淆，问题通常是连续，公共，上升（递增）三词随意组合，本系列就最长子串（子序列）问题进行归纳对比
利用C++实现最长公共子序列与最长公共子串
09-01
【最长公共子序列与最长公共子串的概念】 在计算机科学中，字符串处理是常见的任务之一，其中最长公共子序列（Longest Common Subsequence, LCS）和最长公共子串（Longest Common Substring, LSCS）是两个重要的...
子串和子序列并不是一个意思
热门推荐
穿着裤衩跳
11-21 1万+
例如：一个字符串   awbcdewgh 他的子串：  awbc.   awbcd   awbcde   ....很多个子串  但是都是连续在一起   他的子序列： abc  .  abcd    abcde  ...  很多个子序列  但是子序列中的字符在字符串中不一定是连在一起的   所以  子串！=子序列...
“子序列”与“子串”详解
花言的博客
03-16 5473
子序列与子串的区别 子序列:从从字符串中删除一些字符后不更改剩余字符串字符顺序而生成的序列！ 子 串:原序列中必须连续的一段！ code: #include <vector> #include <string> #include <iostream> using namespace std; void print_vec(const vector<string>& str); //------------------------------
子序列（Subsequence）和子串（Substring）的区别
Kegi_的博客
07-08 2400
4. **例子**：在字符串 "abcdef" 中，"ace" 是一个有效的子序列，因为这些字符在原字符串中保持了原有的顺序，尽管它们之间有其他字符。4. **例子**：在字符串 "abcdef" 中，"bcd" 是一个有效的子串，因为它是连续的字符序列。- **灵活性**：子序列比子串更灵活，因为它允许在保持元素顺序的前提下，跳过一些元素。3. **长度**：子序列的长度也可以是任意的，从0（空序列）到整个序列的长度。- **位置**：子串在原字符串中有固定的位置，子序列则没有这个限制。
子串和子序列的区别
qq_45769627的博客
07-29 3840
子串：原序列中连续的一段 子序列：原序列中不连续的一段 注意：无论是子串和子序列，元素的顺序都是原序列中的顺序
子序列与子串问题总结
fangjian1204的专栏
08-21 1923
1、最长递增子序列 扩展：双duan
Longest Common Subsequence && Substirng【公共子序列及子字符串】【经典dp】
GuoZLH的博客
12-11 698
公共子序列及子字符串问题
浅谈子串和子序列的相同点和不同点
Y
04-24 1万+
子串（substring）和子序列 （subsequence）的区别是什么？ 之前没有细心理解过二者概念，今天自己来补一下这方面知识。 1 背景介绍 在做算法题的时候，经常会遇到子序列问题，如 Logest Increasing Subsequence 问题 如对于序列数组：[4 ,2, 4，5, 3, 7] 最长的递增子序列是 [2, 4， 3, 7] 和之前学习到子串的定义感觉有所不同，但又说不上来什么不同。比较直观的理解就是，可以在原来数组中任意划掉一个或者多个元素，就可以构出子序列。 如划掉2； [
动态规划与子序列和子串的整理
颜之年
04-12 260
整理一下动态规划与子串子序列相关的内容： 花了一天时间，重新做了一遍，感觉手很生，有些地方调试了很久才好，唉。 最长公共子序列： 带路径输出的最长公共子序列： 最长公共子串： 最长上升子序列： 最长上升子串： 最长回文子序列： 最长回文子串： 1.最长公共子序列： #define MAX 1000 int arr[MAX + 1][MAX + 1] { 0 }; int main() { s...
最长公共子序列和公共子串
虚怀若谷
04-17 134
public class Main { public static void main(String[] args) { String a = "asdf"; String b = "pqwersd12f3"; // System.out.println(findLong(a, 3, b, 10, new StringBuilder()).r...
最长公共子序列和子串
ACM之路
01-01 195
class Solution { public: int findLength(vector&lt;int&gt;&amp; A, vector&lt;int&gt;&amp; B) { int n = A.size(); int m = B.size(); vector&lt;vector&lt;int&gt;&gt; dp(n + 1, ...
子序列和子串的区别
最新发布
07-23
<think>首先，用户的问题是：“我想理解子序列和子串在计算机科学中的区别 请问子序列和子串的区别 计算机科学 基础概念”。这涉及到计算机科学中的基本概念。 根据系统指令： - 所有行内数学表达式必须使用$...$格式。 - 独立公式必须使用$$...$$格式并单独成段。 - 使用中文回答。 - 生成相关问题。 - 回答中引用的段落末尾自然地添加引用标识。 - 回答结构清晰，帮助用户逐步解决问题。 参考站内引用： - 引用[1]提到：子序列和子串是基本概念，在公共子序列问题中常用。 - 引用[2]：字符串的最长公共子序列（LCS）是动态规划的范畴。 - 引用[3]：子序列是从序列中派生出来的序列，元素相对顺序不变；子序列可以不连续。 - 引用[4]：LCS问题中，子序列可以不是连续的，但相对顺序一样；子串是连续的。 - 引用[5]：子序列可以不连续，而子串要求连续。 关键区别： - 子串（Substring）：必须是原字符串中连续的一段字符序列。 - 子序列（Subsequence）：可以从原序列中删除一些元素（不一定连续），但保持元素的相对顺序。 例如： - 对于字符串 "ABCD": - 子串： "AB", "BC", "CD", "ABC" 等（连续）。 - 子序列： "AC", "AD", "BD" 等（不连续，但顺序保持）。 在数学表达式中： - 如果提到序列，可以用数学符号表示。例如，序列 $S = s_1, s_2, \dots, s_n$。 - 子序列： $S' = s_{i_1}, s_{i_2}, \dots, s_{i_k}$ where $1 \leq i_1 < i_2 < \dots < i_k \leq n$。 - 子串： $S' = s_i, s_{i+1}, \dots, s_j$ for some $1 \leq i \leq j \leq n$。 回答结构： 1. **引入概念**：解释子序列和子串的定义。 2. **区别对比**：清晰地列出主要区别。 3. **例子说明**：用简单例子展示区别。 4. **应用场景**：简要提及在计算机科学中的应用，如最长公共子序列（LCS）问题。 5. **生成相关问题**：在末尾添加相关问题。 生成相关问题： - 基于主题，如： 1. 最长公共子序列问题如何解决？ 2. 子序列和子串在算法设计中的重要性？ 3. 实际应用场景，如生物信息学或文本比较。 引用标识：在回答中，如果引用参考内容，添加引用标识如 [^1]。参考引用中，[1]到[5]都涉及子序列和子串，所以可以在相关部分添加。 完整回答： - 用中文。 - 结构清晰：先定义，再区别，例子，应用。 - 确保LaTeX语法正确。</think>### 子序列和子串在计算机科学中的区别 在计算机科学中，子序列和子串是序列处理中的基础概念，常用于字符串比较、算法设计（如动态规划）和生物信息学等领域。它们虽然都表示从原序列中派生出的部分序列，但核心区别在于**连续性要求**和**元素顺序**。下面我将逐步解释它们的定义、区别、示例和应用，帮助您清晰理解。 #### 1. **基本定义** - **子串（Substring）**：指原字符串中**连续的一段字符序列**。子串必须保持元素的连续性和相对顺序，不能跳过任何元素。 例如，对于字符串 $S = "ABCD"$，子串可以是 $"AB"$ 或 $"BCD"$（因为它们是连续的片段）。 - **子序列（Subsequence）**：指从原序列中**删除部分元素后得到的序列**，但保留元素的**相对顺序**。子序列不要求元素连续，可以跳过中间元素。 例如，对于字符串 $S = "ABCD"$，子序列可以是 $"AC"$ 或 $"BD"$（因为 $"A"$ 和 $"C"$ 之间跳过了 $"B"$，但顺序不变）。 #### 2. **关键区别对比** 下表总结了子序列和子串的核心差异： | 特性 | 子串（Substring） | 子序列（Subsequence） | |--------------|----------------------------------------|---------------------------------------| | **连续性** | 必须连续（元素相邻） | 可以不连续（可以跳过元素） | | **元素顺序** | 必须保持原顺序 | 必须保持原顺序 | | **数学表示** | 对于序列 $S = s_1, s_2, \dots, s_n$，子串为 $S_{i:j} = s_i, s_{i+1}, \dots, s_j$（$1 \leq i \leq j \leq n$） | 子序列为 $S' = s_{k_1}, s_{k_2}, \dots, s_{k_m}$（$1 \leq k_1 < k_2 < \dots < k_m \leq n$） | | **示例** | $"ABC"$ 是 $"ABCD"$ 的子串 | $"AC"$ 是 $"ABCD"$ 的子序列 | | **常见问题** | 最长公共子串（要求连续匹配） | 最长公共子序列（LCS，允许不连续匹配）[^4] | #### 3. **示例说明** 假设有两个字符串 $A = "ABCBDAB"$ 和 $B = "BDCAB"$： - **子串示例**：$"CAB"$ 是 $A$ 的子串（因为它是连续片段），但不是 $B$ 的子串（$B$ 中 $"CAB"$ 不连续）。 - **子序列示例**：$"BCAB"$ 是 $A$ 的子序列（元素顺序为 $B \to C \to A \to B$，跳过了部分元素），也是 $B$ 的子序列（顺序相同）。因此，$"BCAB"$ 是两者的一个公共子序列。 #### 4. **应用场景** - **子序列**：广泛用于比较序列相似度，例如： - 最长公共子序列（LCS）问题，用于DNA序列比对（生物信息学）或文本差异检测（如Git版本控制）[^1][^4]。 - 算法实现中通常使用动态规划，因为子序列允许不连续性，便于优化计算[^2]。 - **子串**：适用于需要精确连续匹配的场景，例如： - 字符串搜索（如KMP算法）或关键词匹配。 - 最长公共子串问题，用于检测抄袭或连续模式识别[^5]。 理解这一区别对于学习算法（如动态规划）至关重要。子序列的灵活性使其在复杂序列分析中更常用，而子串的严格连续性则适合精确匹配任务[^3]。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值