子序列、子串问题

最新推荐文章于 2022-04-24 22:48:18 发布
最新推荐文章于 2022-04-24 22:48:18 发布
阅读量579 收藏
点赞数
分类专栏： 算法 C++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/pymqq/article/details/14106247
版权
C++ 同时被 2 个专栏收录
20 篇文章 0 订阅
订阅专栏
算法
14 篇文章 0 订阅
订阅专栏 
#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;
}
pymqq
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
子串和子序列问题-动态规划向
weixin_45532984的博客
10-23 1984
有关于子序列和子串的问题是字符串或者数组经常会遇到的问题，一般我们经常使用多指针，滑动窗口，动态规划的方式去解决，而本篇重点关注能用动态规划解决或者说明显使用动态规划解决的子串问题和子序列问题。子串是字符串中的由连续字符组成的一个序列，重点在于连续。例如，"1AB2345CD"，那么"1AB23"，"5CD"都是相应的子串，而"12345CD"不是，已经不是连续的状态。字符串的一个子序列是原始字符串删除一些（也可以不删除）字符而不改变剩余字符相对位置形成的新字符串，那么很明显，子序列和子串最大的区别就是可
子串和子序列
sinoai
06-22 1225
算法题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 292
最长公共子序列 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 184
LCS 转载于:https://www.cnblogs.com/shnuxiaoan/p/11159287.html
利用C++实现最长公共子序列与最长公共子串
12-31
子串应该比较好理解，至于什么是子序列，这里给出一个例子：有两个母串 cnblogs belong 比如序列bo, bg, lg在母串cnblogs与belong中都出现过并且出现顺序与母串保持一致，我们将其称为公共子序列。最长公共子序列...
求解最大子序列、最长递增子序列、最长公共子串、最长公共子序列
12-16
求解最大子序列、最长递增子序列、最长公共子串、最长公共子序列. http://blog.csdn.net/ssuchange/article/details/17341693
详解Python最长公共子串和最长公共子序列的实现
09-20
**Python中最长公共子串（Longest Common Substring, LCS）和最长公共子序列（Longest Common Subsequence, LSC）是字符串处理中常见的算法问题。** **最长公共子串**指的是两个给定字符串中，最长的连续字符序列，...
最长子串问题C语言
03-29
子串和子序列并不是一个意思
热门推荐
穿着裤衩跳
11-21 1万+
例如：一个字符串   awbcdewgh 他的子串：  awbc.   awbcd   awbcde   ....很多个子串  但是都是连续在一起   他的子序列： abc  .  abcd    abcde  ...  很多个子序列  但是子序列中的字符在字符串中不一定是连在一起的   所以  子串！=子序列...
“子序列”与“子串”详解
花言的博客
03-16 5200
子序列与子串的区别 子序列:从从字符串中删除一些字符后不更改剩余字符串字符顺序而生成的序列！ 子 串:原序列中必须连续的一段！ code: #include <vector> #include <string> #include <iostream> using namespace std; void print_vec(const vector<string>& str); //------------------------------
子串和子序列的区别
qq_45769627的博客
07-29 3638
子串：原序列中连续的一段 子序列：原序列中不连续的一段 注意：无论是子串和子序列，元素的顺序都是原序列中的顺序
子序列与子串问题总结
fangjian1204的专栏
08-21 1870
1、最长递增子序列 扩展：双duan
Longest Common Subsequence && Substirng【公共子序列及子字符串】【经典dp】
GuoZLH的博客
12-11 638
公共子序列及子字符串问题
浅谈子串和子序列的相同点和不同点
Y
04-24 6844
子串（substring）和子序列 （subsequence）的区别是什么？ 之前没有细心理解过二者概念，今天自己来补一下这方面知识。 1 背景介绍 在做算法题的时候，经常会遇到子序列问题，如 Logest Increasing Subsequence 问题 如对于序列数组：[4 ,2, 4，5, 3, 7] 最长的递增子序列是 [2, 4， 3, 7] 和之前学习到子串的定义感觉有所不同，但又说不上来什么不同。比较直观的理解就是，可以在原来数组中任意划掉一个或者多个元素，就可以构出子序列。 如划掉2； [
动态规划与子序列和子串的整理
颜之年
04-12 197
整理一下动态规划与子串子序列相关的内容： 花了一天时间，重新做了一遍，感觉手很生，有些地方调试了很久才好，唉。 最长公共子序列： 带路径输出的最长公共子序列： 最长公共子串： 最长上升子序列： 最长上升子串： 最长回文子序列： 最长回文子串： 1.最长公共子序列： #define MAX 1000 int arr[MAX + 1][MAX + 1] { 0 }; int main() { s...
最长公共子序列和公共子串
虚怀若谷
04-17 97
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 145
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, ...
子序列和子串问题算法的全面总结
qq_41633237的博客
05-08 1万+
1.分清楚什么是子串，什么是子序列 看文章前首先要搞清楚什么是子序列，什么是子串；子序列是指一个字串中非连续的字串，例如：字串A：123456789 它有一个子序列a：13579（非连续） 它有一个子串b：12345（连续）。 2.有关子串问题的算法 （1）最大子串 何为最大子串，例如：最大子串是要找出由数组成的一维数组中和最大的连续子串。比如{5,-3,4,2}的最大子串就是 {5,-3...
子序列和子串有什么区别
最新发布
03-08
子序列和子串的区别在于子序列可以不连续，而子串必须是连续的一段。例如，字符串"abcd"的子序列有"a", "b", "c", "d", "ab", "ac", "ad", "bc", "bd", "cd", "abc", "abd", "acd", "bcd", "abcd"，而子串只有"a", ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值