最长公共子串与最长公共子序列

最新推荐文章于 2024-03-02 17:16:01 发布
最新推荐文章于 2024-03-02 17:16:01 发布
阅读量303 收藏
点赞数
分类专栏： C/C++ 文章标签： DP动态规划

 本文转载于http://blog.csdn.net/hackbuteer1/article/details/6686931


子字符串的定义和子序列的定义类似，但要求是连续分布在其他字符串中。比如输入两个字符串BDCABA和ABCBDAB的最长公共字符串有BD和AB，它们的长度都是2。

      最长公共子字符串共有两种解决方法，下面具体说说我的思路

方法一：

     Longest Common Substring和Longest Common Subsequence是有区别的

     X = <a, b, c, f, b, c>

     Y = <a, b, f, c, a, b>

     X和Y的Longest Common Sequence为<a, b, c, b>，长度为4

     X和Y的Longest Common Substring为 <a, b>长度为2

    其实Substring问题是Subsequence问题的特殊情况，也是要找两个递增的下标序列

    <i1, i2, ...ik> 和 <j1, j2, ..., jk>使

     xi1 == yj1

    xi2 == yj2

    ......

    xik == yjk

    与Subsequence问题不同的是，Substring问题不光要求下标序列是递增的，还要求每次

   递增的增量为1， 即两个下标序列为：

   <i, i+1, i+2, ..., i+k-1> 和 <j, j+1, j+2, ..., j+k-1>

    类比Subquence问题的动态规划解法，Substring也可以用动态规划解决，令

    c[i][j]表示Xi和Yi的最大Substring的长度，比如

   X = <y, e, d, f>

   Y = <y, e, k, f>

   c[1][1] = 1

   c[2][2] = 2

   c[3][3] = 0

   c[4][4] = 1

   动态转移方程为：

   如果xi == yj， 则 c[i][j] = c[i-1][j-1]+1

   如果xi ! = yj,  那么c[i][j] = 0

   最后求Longest Common Substring的长度等于

   max{  c[i][j],  1<=i<=n， 1<=j<=m}

 完整的代码如下：

[cpp] view plain copy
print ?
  1. /**  
  2. 找出两个字符串的最长公共连续子串的长度 
  3. ** author :liuzhiwei   
  4. ** data   :2011-08-16 
  5. **/   
  6. #include "stdio.h"  
  7. #include "string.h"  
  8. #include "stdlib.h"  
  9.   
  10. int longest_common_substring(char *str1, char *str2)  
  11. {  
  12.     int i,j,k,len1,len2,max,x,y;  
  13.     len1 = strlen(str1);  
  14.     len2 = strlen(str2);  
  15.     int **c = new int*[len1+1];  
  16.     for(i = 0; i < len1+1; i++)  
  17.         c[i] = new int[len2+1];  
  18.     for(i = 0; i < len1+1; i++)  
  19.         c[i][0]=0;        //第0列都初始化为0  
  20.     for(j = 0; j < len2+1; j++)  
  21.         c[0][j]=0;        //第0行都初始化为0   
  22.     max = -1;  
  23.     for(i = 1 ; i < len1+1 ; i++)  
  24.     {  
  25.         for(j = 1; j < len2+1; j++)  
  26.         {  
  27.             if(str1[i-1]==str2[j-1])     //只需要跟左上方的c[i-1][j-1]比较就可以了  
  28.                 c[i][j]=c[i-1][j-1]+1;  
  29.             else                         //不连续的时候还要跟左边的c[i][j-1]、上边的c[i-1][j]值比较，这里不需要  
  30.                 c[i][j]=0;  
  31.             if(c[i][j]>max)  
  32.             {  
  33.                 max=c[i][j];  
  34.                 x=i;  
  35.                 y=j;  
  36.             }  
  37.         }  
  38.     }  
  39.   
  40.     //输出公共子串  
  41.     char s[1000];  
  42.     k=max;  
  43.     i=x-1,j=y-1;  
  44.     s[k--]='\0';  
  45.     while(i>=0 && j>=0)  
  46.     {  
  47.         if(str1[i]==str2[j])  
  48.         {  
  49.             s[k--]=str1[i];  
  50.             i--;  
  51.             j--;  
  52.         }  
  53.         else       //只要有一个不相等，就说明相等的公共字符断了，不连续了  
  54.             break;  
  55.     }  
  56.     printf("最长公共子串为：");  
  57.     puts(s);  
  58.     for(i = 0; i < len1+1; i++)         //释放动态申请的二维数组  
  59.         delete[] c[i];  
  60.     delete[] c;  
  61.     return max;  
  62. }  
  63. int main(void)  
  64. {  
  65.     char str1[1000],str2[1000];  
  66.     printf("请输入第一个字符串：");  
  67.     gets(str1);  
  68.     printf("请输入第二个字符串：");  
  69.     gets(str2);  
  70.     int len = longest_common_substring(str1, str2);  
  71.     printf("最长公共连续子串的长度为：%d\n",len);  
  72.     system("pause");  
  73.     return 0;  
  74. }  

/** 
找出两个字符串的最长公共连续子串的长度
** author :liuzhiwei  
** data   :2011-08-16
**/ 
#include "stdio.h"
#include "string.h"
#include "stdlib.h"

int longest_common_substring(char *str1, char *str2)
{
	int i,j,k,len1,len2,max,x,y;
	len1 = strlen(str1);
	len2 = strlen(str2);
	int **c = new int*[len1+1];
	for(i = 0; i < len1+1; i++)
		c[i] = new int[len2+1];
	for(i = 0; i < len1+1; i++)
		c[i][0]=0;        //第0列都初始化为0
	for(j = 0; j < len2+1; j++)
		c[0][j]=0;        //第0行都初始化为0 
	max = -1;
	for(i = 1 ; i < len1+1 ; i++)
	{
		for(j = 1; j < len2+1; j++)
		{
			if(str1[i-1]==str2[j-1])     //只需要跟左上方的c[i-1][j-1]比较就可以了
				c[i][j]=c[i-1][j-1]+1;
			else                         //不连续的时候还要跟左边的c[i][j-1]、上边的c[i-1][j]值比较，这里不需要
				c[i][j]=0;
			if(c[i][j]>max)
			{
				max=c[i][j];
				x=i;
				y=j;
			}
		}
	}

	//输出公共子串
	char s[1000];
	k=max;
	i=x-1,j=y-1;
	s[k--]='\0';
	while(i>=0 && j>=0)
	{
		if(str1[i]==str2[j])
		{
			s[k--]=str1[i];
			i--;
			j--;
		}
		else       //只要有一个不相等，就说明相等的公共字符断了，不连续了
			break;
	}
	printf("最长公共子串为：");
	puts(s);
	for(i = 0; i < len1+1; i++)         //释放动态申请的二维数组
		delete[] c[i];
	delete[] c;
	return max;
}
int main(void)
{
	char str1[1000],str2[1000];
	printf("请输入第一个字符串：");
	gets(str1);
	printf("请输入第二个字符串：");
	gets(str2);
	int len = longest_common_substring(str1, str2);
	printf("最长公共连续子串的长度为：%d\n",len);
	system("pause");
	return 0;
}

        效果图如下：

方法二：

      将字符串s1和s2分别写在两把直尺上面(我依然用s1，s2来表示这两把直尺)，然后将s1固定，s2的头部和s1的尾部对齐，然后逐渐移动直尺s2，比较重叠部分的字符串中的公共子串的长度，直到直尺s2移动到s1的头部。在这个过程中求得的最大长度就是s1、s2最大子串的长度。

     下图是求解过程的图示（下图有点错误，应该是将s2从右往左移动），蓝色部分表示重叠的字符串，红色的部分表示重叠部分相同的子串

      其中s1="shaohui"，s2="ahui"，最后求得的结果为3

      完整的代码如下：

[cpp] view plain copy
print ?
  1. /**  
  2. 找出两个字符串的最长公共连续子串的长度 
  3. ** author :liuzhiwei   
  4. ** data   :2011-08-16 
  5. **/   
  6. #include "stdio.h"  
  7. #include "string.h"  
  8. #include "stdlib.h"  
  9.   
  10. int longest_common_substring(char *str1, char *str2)  
  11. {  
  12.     int i,len1,len2,len,s1_start,s2_start,idx,curmax,max;  
  13.     len1 = strlen(str1);  
  14.     len2 = strlen(str2);  
  15.     len = len1 + len2;  
  16.     max = 0;  
  17.     for(i = 0 ; i < len ; i++)  
  18.     {  
  19.         s1_start = s2_start = 0;  
  20.         if(i < len1)  
  21.             s1_start = len1 - i;    //每次开始匹配的起始位置  
  22.         else  
  23.             s2_start = i - len1;  
  24.         curmax = 0;  
  25.         for(idx = 0 ; ( s1_start + idx < len1 ) && ( s2_start + idx < len2 ); idx++ )  
  26.         {  
  27.             if(str1[s1_start+idx]==str2[s2_start+idx])  
  28.                 curmax++;  
  29.             else     //只要有一个不相等，就说明相等的公共字符断了，不连续了，要保存curmax与max中的最大值，并将curmax重置为0  
  30.             {  
  31.                 max = curmax > max ? curmax : max;  
  32.                 curmax = 0;  
  33.             }  
  34.         }  
  35.         max = curmax > max ? curmax : max;  
  36.     }  
  37.     return max;  
  38. }  
  39. int main(void)  
  40. {  
  41.     char str1[1000],str2[1000];  
  42.     printf("请输入第一个字符串：");  
  43.     gets(str1);  
  44.     printf("请输入第二个字符串：");  
  45.     gets(str2);  
  46.     int len = longest_common_substring(str1, str2);  
  47.     printf("最长公共连续子串的长度为：%d\n",len);  
  48.     system("pause");  
  49.     return 0;  
  50. }  
/** 
找出两个字符串的最长公共连续子串的长度
** author :liuzhiwei  
** data   :2011-08-16
**/ 
#include "stdio.h"
#include "string.h"
#include "stdlib.h"

int longest_common_substring(char *str1, char *str2)
{
	int i,len1,len2,len,s1_start,s2_start,idx,curmax,max;
	len1 = strlen(str1);
	len2 = strlen(str2);
	len = len1 + len2;
	max = 0;
	for(i = 0 ; i < len ; i++)
	{
		s1_start = s2_start = 0;
		if(i < len1)
			s1_start = len1 - i;    //每次开始匹配的起始位置
		else
			s2_start = i - len1;
		curmax = 0;
		for(idx = 0 ; ( s1_start + idx < len1 ) && ( s2_start + idx < len2 ); idx++ )
		{
			if(str1[s1_start+idx]==str2[s2_start+idx])
				curmax++;
			else     //只要有一个不相等，就说明相等的公共字符断了，不连续了，要保存curmax与max中的最大值，并将curmax重置为0
			{
				max = curmax > max ? curmax : max;
				curmax = 0;
			}
		}
		max = curmax > max ? curmax : max;
	}
	return max;
}
int main(void)
{
	char str1[1000],str2[1000];
	printf("请输入第一个字符串：");
	gets(str1);
	printf("请输入第二个字符串：");
	gets(str2);
	int len = longest_common_substring(str1, str2);
	printf("最长公共连续子串的长度为：%d\n",len);
	system("pause");
	return 0;
}

      效果图如下：

         稍微改动一下，便可以输出公共子串了，就是要保存一下连续公共子串最后一个字符在其中一个字符串中的下标位置：

[cpp] view plain copy
print ?
  1. /**  
  2. 找出两个字符串的最长公共连续子串的长度 
  3. ** author :liuzhiwei   
  4. ** data   :2011-08-16 
  5. **/   
  6. #include "stdio.h"  
  7. #include "string.h"  
  8. #include "stdlib.h"  
  9.   
  10. int longest_common_substring(char *str1, char *str2)  
  11. {  
  12.     int i,k,len1,len2,len,s1_start,s2_start,idx,curmax,max;  
  13.     len1 = strlen(str1);  
  14.     len2 = strlen(str2);  
  15.     len = len1 + len2;  
  16.     max = 0;  
  17.     for(i = 0 ; i < len ; i++)  
  18.     {  
  19.         s1_start = s2_start = 0;  
  20.         if(i < len1)  
  21.             s1_start = len1 - i;    //每次开始匹配的起始位置  
  22.         else  
  23.             s2_start = i - len1;  
  24.         curmax = 0;  
  25.         for(idx = 0 ; ( s1_start + idx < len1 ) && ( s2_start + idx < len2 ); idx++ )  
  26.         {  
  27.             if(str1[s1_start+idx]==str2[s2_start+idx])  
  28.                 curmax++;  
  29.             else     //只要有一个不相等，就说明相等的公共字符断了，不连续了，要保存curmax与max中的最大值，并将curmax重置为0  
  30.             {  
  31.                 //max = curmax > max ? curmax : max;  
  32.                 if(curmax > max)  
  33.                 {  
  34.                     max = curmax;  
  35.                     k = s1_start+idx-1;      //保存连续子串长度增加时连续子串最后一个字符在str1字符串中的下标位置，便于输出公共连续子串  
  36.                 }  
  37.                 curmax = 0;  
  38.             }  
  39.         }  
  40.         //max = curmax > max ? curmax : max;  
  41.         if(curmax > max)  
  42.         {  
  43.             max = curmax;  
  44.             k = s1_start+idx-1;  
  45.         }  
  46.     }  
  47.   
  48.     //输出公共子串  
  49.     char s[1000];  
  50.     for(i=0;i<max;i++)  
  51.         s[i]=str1[k-max+1+i];     //公共字串在str1中的下标起始位置为k-max+1，结束位置为k  
  52.     s[i]='\0';  
  53.     printf("最长公共子串为：");  
  54.     puts(s);  
  55.     return max;  
  56. }  
  57. int main(void)  
  58. {  
  59.     char str1[1000],str2[1000];  
  60.     printf("请输入第一个字符串：");  
  61.     gets(str1);  
  62.     printf("请输入第二个字符串：");  
  63.     gets(str2);  
  64.     int len = longest_common_substring(str1, str2);  
  65.     printf("最长公共连续子串的长度为：%d\n",len);  
  66.     system("pause");  
  67.     return 0;  
  68. }  
/** 
找出两个字符串的最长公共连续子串的长度
** author :liuzhiwei  
** data   :2011-08-16
**/ 
#include "stdio.h"
#include "string.h"
#include "stdlib.h"

int longest_common_substring(char *str1, char *str2)
{
	int i,k,len1,len2,len,s1_start,s2_start,idx,curmax,max;
	len1 = strlen(str1);
	len2 = strlen(str2);
	len = len1 + len2;
	max = 0;
	for(i = 0 ; i < len ; i++)
	{
		s1_start = s2_start = 0;
		if(i < len1)
			s1_start = len1 - i;    //每次开始匹配的起始位置
		else
			s2_start = i - len1;
		curmax = 0;
		for(idx = 0 ; ( s1_start + idx < len1 ) && ( s2_start + idx < len2 ); idx++ )
		{
			if(str1[s1_start+idx]==str2[s2_start+idx])
				curmax++;
			else     //只要有一个不相等，就说明相等的公共字符断了，不连续了，要保存curmax与max中的最大值，并将curmax重置为0
			{
				//max = curmax > max ? curmax : max;
				if(curmax > max)
				{
					max = curmax;
					k = s1_start+idx-1;      //保存连续子串长度增加时连续子串最后一个字符在str1字符串中的下标位置，便于输出公共连续子串
				}
				curmax = 0;
			}
		}
		//max = curmax > max ? curmax : max;
		if(curmax > max)
		{
			max = curmax;
			k = s1_start+idx-1;
		}
	}

	//输出公共子串
	char s[1000];
	for(i=0;i<max;i++)
		s[i]=str1[k-max+1+i];     //公共字串在str1中的下标起始位置为k-max+1，结束位置为k
	s[i]='\0';
	printf("最长公共子串为：");
	puts(s);
	return max;
}
int main(void)
{
	char str1[1000],str2[1000];
	printf("请输入第一个字符串：");
	gets(str1);
	printf("请输入第二个字符串：");
	gets(str2);
	int len = longest_common_substring(str1, str2);
	printf("最长公共连续子串的长度为：%d\n",len);
	system("pause");
	return 0;
}

       效果图如下：

         扩展：子串也可以是反串，比如HDOJ 1238

         题目意思是要搜索最长的子串

        给出一系列字符串,几个子串可以是反串

        rose
       orchid 

       这里最长的子串是 ro 跟or 长度为2。

       如果穷举搜索的话,肯定过不了。

       所以可以找出所有字符串中最短的串,枚举最短的字符串的子串

       判断是否都是别的字符串的子串，求出最大长度即可。。

[cpp] view plain copy
print ?
  1. /**  
  2. 找出两个字符串的最长公共连续子串的长度 
  3. ** author :liuzhiwei   
  4. ** data   :2011-08-16 
  5. **/   
  6. #include "stdio.h"  
  7. #include "string.h"  
  8. #include "stdlib.h"  
  9.   
  10. char str[100][100];  
  11. int k;  
  12. int match(int start,int end,int n)   //最短字符串中的起点下标、终点下标，字符串总数  
  13. {  
  14.     int i,j,len,p,h;  
  15.     for(i=0;i<n;i++)  
  16.     {  
  17.         if(i==k)  
  18.             continue;  
  19.         len=strlen(str[i]);  
  20.         for(j=0;j<=len-1-end+start;j++)    //str[i]字符串可以组成len-1-end+start个长度为end-start的连续子串  
  21.         {  
  22.             for(p=start,h=j;p<=end;p++,h++)    //顺序判断子串  
  23.             {  
  24.                 if(str[k][p]!=str[i][h])       //不等即跳出  
  25.                     break;  
  26.             }  
  27.             if(p>end)                   //如果全部相等，则匹配成功，终止  
  28.                 break;  
  29.   
  30.             for(p=end,h=j;p>=start;p--,h++)             //逆序判断子串  
  31.             {  
  32.                 if(str[k][p]!=str[i][h])       //不等即跳出  
  33.                     break;  
  34.             }  
  35.             if(p<start)                   //如果全部相等，则匹配成功，终止  
  36.                 break;  
  37.         }  
  38.         if(j>len-1-end+start)    //如果搜索完毕都没终止,即无匹配  
  39.             return 0;  
  40.     }  
  41.     return 1;  
  42. }  
  43. int main(void)  
  44. {  
  45.     int t,i,j,n,len,minlen,flag;  
  46.     scanf("%d",&t);  
  47.     while(t--)  
  48.     {  
  49.         minlen=1000,flag=0;  
  50.         scanf("%d",&n);  
  51.         for(i=0;i<n;i++)  
  52.         {  
  53.             scanf("%s",str[i]);  
  54.             len = strlen(str[i]);  
  55.             if(len<minlen)  
  56.             {  
  57.                 minlen=len;      //保存最短字符串的长度  
  58.                 k=i;             //保存最短字符串的序号  
  59.             }  
  60.         }  
  61.         for(i=0;i<minlen;i++)    //对最短字符串的连续字串进行匹配查找  
  62.         {  
  63.             for(j=0;j<=i;j++)  
  64.             {  
  65.                 if(match(j,j+minlen-1-i,n))    //子串是否匹配  
  66.                 {  
  67.                     flag=1;  
  68.                     break;  
  69.                 }  
  70.             }  
  71.             if(flag==1)  
  72.                 break;  
  73.         }  
  74.         printf("%d\n",minlen-i);  
  75.     }  
  76.     system("pause");  
  77.     return 0;  
  78. }  
/** 
找出两个字符串的最长公共连续子串的长度
** author :liuzhiwei  
** data   :2011-08-16
**/ 
#include "stdio.h"
#include "string.h"
#include "stdlib.h"

char str[100][100];
int k;
int match(int start,int end,int n)   //最短字符串中的起点下标、终点下标，字符串总数
{
	int i,j,len,p,h;
	for(i=0;i<n;i++)
	{
		if(i==k)
			continue;
		len=strlen(str[i]);
		for(j=0;j<=len-1-end+start;j++)    //str[i]字符串可以组成len-1-end+start个长度为end-start的连续子串
		{
			for(p=start,h=j;p<=end;p++,h++)    //顺序判断子串
			{
				if(str[k][p]!=str[i][h])       //不等即跳出
					break;
			}
			if(p>end)                   //如果全部相等，则匹配成功，终止
				break;

			for(p=end,h=j;p>=start;p--,h++)             //逆序判断子串
			{
				if(str[k][p]!=str[i][h])       //不等即跳出
					break;
			}
			if(p<start)                   //如果全部相等，则匹配成功，终止
				break;
		}
		if(j>len-1-end+start)    //如果搜索完毕都没终止,即无匹配
			return 0;
	}
	return 1;
}
int main(void)
{
	int t,i,j,n,len,minlen,flag;
	scanf("%d",&t);
	while(t--)
	{
		minlen=1000,flag=0;
		scanf("%d",&n);
		for(i=0;i<n;i++)
		{
			scanf("%s",str[i]);
			len = strlen(str[i]);
			if(len<minlen)
			{
				minlen=len;      //保存最短字符串的长度
				k=i;             //保存最短字符串的序号
			}
		}
		for(i=0;i<minlen;i++)    //对最短字符串的连续字串进行匹配查找
		{
			for(j=0;j<=i;j++)
			{
				if(match(j,j+minlen-1-i,n))    //子串是否匹配
				{
					flag=1;
					break;
				}
			}
			if(flag==1)
				break;
		}
		printf("%d\n",minlen-i);
	}
	system("pause");
	return 0;
}




最长公共子序列

# define N 1000

int str[N+2][N+2];

int main()

{

    int i,j,la,lb;

    charstr1[N+1],str2[N+1];

    while(scanf("%s%s",str1,str2)!=EOF)

    {

         la=strlen(str1);

         lb=strlen(str2);

         for(i=0;i<=la;i++)str[0][i]=0;

         for(j=0;j<=lb;j++)str[j][0]=0;

         for(j=0;j<la;j++)//枚举断点

             for(i=0;i<lb;i++)

             {

                  if(str1[j]==str2[i])str[i+1][j+1]=str[i][j]+1;

                  elsestr[i+1][j+1]=max(str[i][j+1],str[i+1][j]);

             }

          printf("%d/n",str[lb][la]);

    }

     return 0;

}

最长公共子串

/*
int longest_common_substring(char *str1, char *str2)
{
 int i,j,k,len1,len2,max,x,y;
 len1 = strlen(str1);
 len2 = strlen(str2);
 int **c = new int*[len1+1];
 for(i = 0; i < len1+1; i++)
  c[i] = new int[len2+1];
 for(i = 0; i < len1+1; i++)
  c[i][0]=0;        //第0列都初始化为0
 for(j = 0; j < len2+1; j++)
  c[0][j]=0;        //第0行都初始化为0
 max = -1;
 for(i = 1 ; i < len1+1 ; i++)
 {
  for(j = 1; j < len2+1; j++)
  {
   if(str1[i-1]==str2[j-1])     //只需要跟左上方的c[i-1][j-1]比较就可以了
    c[i][j]=c[i-1][j-1]+1;
   else                         //不连续的时候还要跟左边的c[i][j-1]、上边的c[i-1][j]值比较，这里不需要
    c[i][j]=0;
   if(c[i][j]>max)
   {
    max=c[i][j];
    x=i;
    y=j;
   }
  }
 }
 //输出公共子串
 char s[1000];
 k=max;
 i=x-1,j=y-1;
 s[k--]='\0';
 while(i>=0 && j>=0)
 {
  if(str1[i]==str2[j])
  {
   s[k--]=str1[i];
   i--;
   j--;
  }
  else       //只要有一个不相等，就说明相等的公共字符断了，不连续了
   break;
 }
 //printf("最长公共子串为：");
 //puts(s);
 for(i = 0; i < len1+1; i++)         //释放动态申请的二维数组
  delete[] c[i];
 delete[] c;
 return max;
}
*/
int main()
{
 char str2[1000];
 char* str1 = "abcdefghijklmnopqrstuvwxyz";
 gets(str2);
 int len = longest_common_substring(str1, str2);
 printf("%d\n",26-len);
 system("pause");
 return 0;
}


Junruiqwertyuiop
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
动态规划经典问题 - 求最长公共子串 / 公共子序列
chenyao的博客~
05-24 1736
首先要理解公共子串和公共子序列 公共子串和公共子序列是两个不相同的概念, 公共子串要求字符连续, 公共子序列不要求字符连续。 比如: 字符串"ascde", “axcxdde” 最长公共子串是 “de” , 因为 "de"在两个字符串中都是连续的 最长公共子序列是 “acde”, 不要求连续, 只要满足两个字符串中子序列前后顺序的一致即可 动态规划求最长公共子序列 动态规划的核心是 base case 状态转移方程 自下而上 我们可以通过状态转移表来帮助我们得出状态转移方程 这里我直接说结论: 我们思考
深刻理解最长公共子串、最长公共子序列（应该比较全面）
11-21 2286
这里写自定义目录标题 理论知识： 推荐参考该博文：java实现字符串匹配问题之求两个字符串的最大公共子串 当然这篇也一样，看个人理解：求两个字符串的最长公共子串 图形理解： ...
最长公共子串和最长公共子序列
Tacit_zfy99的博客
05-19 175
学习目标： 提示：这里可以添加学习目标 例如：一周掌握 Java 入门知识 学习内容： 提示：这里可以添加要学的内容 例如： 1、 搭建 Java 开发环境 2、 掌握 Java 基本语法 3、 掌握条件语句 4、 掌握循环语句 学习时间： 提示：这里可以添加计划学习的时间 例如： 1、 周一至周五晚上 7 点—晚上9点 2、 周六上午 9 点-上午 11 点 3、 周日下午 3 点-下午 6 点 学习产出： 提示：这里统计学习计划的总量 例如： 1、 技术笔记 2 遍 2、CSDN 技术博客 3 篇
动态规划---最长公共子序列和最长公共子串
weixin_46077587的博客
05-08 803
说到动态规划，不得不说到经典的最长公共子序列（Longest Common Sequence）问题和最长公共子串（Longest Common Substring），都被称为LCS问题 其中最长公共子串是最长公共子序列的衍生问题，我们今天来重点讨论一下这两个问题。 首先我们先区分一下最长公共子序列和最长公共子串，直接举一个例子就能明白。比如给你两个字符串分别数adminos和admins,请问它们的最长公共子序列和最长公共子串分别是什么嘞？ 最长公共子序列：admins 最长公共子串：admin 通过比较，
“子序列”与“子串”详解
花言的博客
03-16 5204
子序列与子串的区别 子序列:从从字符串中删除一些字符后不更改剩余字符串字符顺序而生成的序列！ 子 串:原序列中必须连续的一段！ code: #include <vector> #include <string> #include <iostream> using namespace std; void print_vec(const vector<string>& str); //------------------------------
利用C++实现最长公共子序列与最长公共子串
12-31
最长公共子序列（Longest Common Subsequence, LCS），顾名思义，是指在所有的子序列中最长的那一个。子串是要求更严格的一种子序列，要求在母串中连续地出现。在上述例子的中，最长公共子序列为blog（cnblogs, ...
C语言求两个字符串的最长公共子串
09-03
最长公共子串是指在两个或多个字符串中都存在的、且长度最长的连续字符序列。这个问题在文本处理、数据比较和生物信息学等领域都有广泛的应用。 首先，我们需要了解C语言中的字符串处理基础。在C语言中，字符串是以...
详解Python最长公共子串和最长公共子序列的实现
09-20
**最长公共子序列**与最长公共子串的区别在于，子序列不要求字符间的顺序连续。LCS可以用于衡量两段文本的相似性，比如检测抄袭。解决LCS问题同样使用动态规划，但矩阵的更新规则有所不同。若字符匹配，当前位置的值...
子串和子序列
最新发布
No__word的博客
03-02 1631
子串（Substring）子串是指原字符串中连续的一段字符组成的序列。换句话说，子串是从原字符串中选取的一个或多个相邻字符构成的新字符串。例如，在字符串 "abcdefg" 中，"abc"、"def" 和 "cde" 都是合法的子串，因为它们都是原字符串中的连续部分。子串的长度至少为1，也可以是整个原字符串（即原字符串本身也是它自己的子串）。
动态规划——最长公共子序列和最长公共子串之Python实现
10-22
用Python实现动态规划中最长公共子序列和最长公共子串问题！
动态规划：最长公共子串 & 最长公共子序列
阿飞的博客
10-18 1万+
一、最长公共子串 1. 题目 给定两个序列 X 和 Y，如果 Z 即是 X 的子串，又是 Y 的子串，我们就称它是 X 和 Y 的公共子串，注意子串是连续的。 例如 X = { A, B, C, D, E, F, G }，Y = { A, B, Z, D, E, F, K, G }，那么它们最长的公共子串即 { D, E, F } 2. 思路 借助一下《图解算法》中的例子。假设对于两个字符串 fi...
算法：最长公共子串和最长公共子序列
English_yang的博客
08-01 200
最长公共子串 ''' 最长公共子串 dp问题 dp[i][j]表示str1[:i]与str2[:j]最长公共子串的长度 ''' def LCS_s(str1,str2):#返回最长公共子串长度 m=len(str1) n=len(str2) dp=[[0]*(n+1) for i in range(m+1)] max_len=0 for i in range(1,m+1): for j in range(1,n+1): .
子串与子序列的区别
num_001的博客
07-12 2634
子串与子序列的区别
最长公共子序列和最长公共子串
Gamma Gao的专栏
04-12 614
动态规划与分治法之间的区别：1.divide and conquer algorithm分治法是指将问题分成一些独立的子问题，递归的求解各子问题。2.dynamic programming algorithm动态规划适用于这些子问题不是独立的情况，也就是各子问题包含公共子问题。最长公共子序列和最长公共子串的区别：找两个字符串的最长公共子串，这个子串要求在原字符串中是连续的；而最长公共子序列则并不要...
最长公共子序列与最长公共子串(DP)
铭霏的记事本
11-16 2万+
1. 问题描述 子串应该比较好理解，至于什么是子序列，这里给出一个例子：有两个母串 cnblogsbelong 比如序列bo, bg, lg在母串cnblogs与belong中都出现过并且出现顺序与母串保持一致，我们将其称为公共子序列。最长公共子序列（Longest Common Subsequence, LCS），顾名思义，是指在所有的子序列中最长的那一个。子串是要求更严格的一种
史上最全最丰富的“最长公共子序列”、“最长公共子串”问题的解法与思路
热门推荐
王小东大将军的博客
07-31 2万+
花了一天时间把一直以来的“最大子序列”、“最大递增子序列“、”最大公共子序列“、“最长公共子串”等问题总结了一下。其中参考了若干博文，都备注引用。 首先子序列是指一个一个序列中，由若个数（字母）组成，然后从中任意删掉几个数（字母），保留剩下的数（字母）构成了一个序列，即称子序列。（或者从一个序列中，任意选取若干数或字符，按照这些数或字符原来的排序组成新的序列，即称子序列） 子串是指在一个字符串
最长公共子序列和最长公共子串(python)
09-06
最长公共子序列（Longest Common Subsequence, LCS）和最长公共子串（Longest Common Substring）是两个常见的字符串相关问题。 最长公共子序列是指给定两个字符串，要求找到它们之间最长的公共子序列的长度。子...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值