本文介绍了一种使用动态规划方法解决最长公共子串问题的高效算法，并提供了详细的步骤解析及代码实现。
比如A = "aocdfe", B = "pmcdfa" 则输出"cdf"
动态规划有一个经典问题是最长公共子序列，但是这里的子序列不要求连续，如果要求序列是连续的，我们叫公共子串，那应该如何得到这个串呢？
最简单的方法就是依次比较，以某个串为母串，然后生成另一个串的所有长度的子串，依次去母串中比较查找，这里可以采用先从最长的子串开始，减少比较次数，但是复杂度依然很高！
然后重新看一下这个问题，我们建立一个比较矩阵来比较两个字符串str1和str2
定义 lcs(i,j) ，当str1[i] = str2[j]时lcs(i,j)=1,否则等于0。
example:
str1 = "bab"
str2 = "caba"
建立矩阵
--b a b
c 0 0 0
a 0 1 0
b 1 0 1
a 0 1 0
连续i子串的特点就是如果str1[i]和str2[j]是属于某公共子串的最后一个字符，那么一定有str1[i]=str2[j] && str1[i-1] = str2[j-1]，从矩阵中直观的看，就是由“1”构成的“斜线”代表的序列都是公共子串，那么最长公共子串肯定就是斜线“1”最长的那个串。
那么现在问题就可以转化了，只要构造出如上的一个矩阵，用n^2的时间就可以得到矩阵，然后再到矩阵中去寻找最长的那个“1”构成的斜线就可以了！那么，现在又有了新的问题？如何快速的找到那个“1”构成的最长斜线呢？
采用DP的思想，如果str1[i] = str2[j]，那么此处的包含str1[i] 和 str2[j]公共子串的长度必然是包含str1[i-1]和str2[j-1]的公共子串的长度加1，那么现在我们可以重新定义lcs(i,j)，即是lcs(i,j) = lcs(i-1,j-1) + 1，反之，lcs(i,j) = 0。那么上面的矩阵就变成了如下的样子：
--b a b
c 0 0 0
a 0 1 0
b 1 0 2
a 0 2 0
现在问题又变简单了，只需要花n^2的时间构造这样一个矩阵，再花n^2的时间去找到矩阵中最大的那个值，对应的就是最长公共子串的长度，而最大值对应的位置对应的字符，就是最长公共子串的最末字符。
算法还可以改进，我们可以将查找最大长度和对应字符的工作放在构造矩阵的过程中完成，一边构造一边记录当前的最大长度和对应位置，这样就节省了n^2的查找时间。
空间上也可以做改进，如果按照如上的方式构造，我们发现，当矩阵的第i+1行的值计算完成后，第i行的值就没有用了，即便是最长的长度出现在第i行，我们也已经用变量记录下来了。因此，可以将矩阵缩减成一个向量来处理，向量的当前值对应第i行，向量的下一个循环后的值对应第i+1行。
代码如下：
// 最长公共子串（连续） LCS
// Deng Chao
// 2012.12.4
#include <iostream>
#include <cstring>
using namespace std;
// 查找公共子串
// lcs记录公共子串
// return 公共子串长度
int LCS(const char *str1 , int len1 , const char *str2 , int len2 , char *&lcs)
{
if(NULL == str1 || NULL == str2)
{
return -1; //空参数
}
// 压缩后的最长子串记录向量
int i, *c = new int[len2+1];
for( i = 0 ; i < len2 ; ++i)
{
c[i] = 0;
}
int max_len = 0; //匹配的长度
int pos = 0; //在str2上的匹配最末位置
for( i = 0 ; i < len1 ; ++i)
{
for(int j = len2 ; j > 0 ; --j) //更新时从后往前遍历
{
if(str1[i] == str2[j-1])
{
c[j] = c[j-1] + 1;
if(c[j] > max_len)
{
max_len = c[j];
pos = j-1;
}
}
else
{
c[j] = 0;
}
}
}
if(0 == max_len)
{
return 0;
}
// 得到公共子串
lcs = new char[max_len];
for( i = 0 ; i < max_len ; ++i)
{
lcs[i] = str2[pos-max_len+1+i];
}
cout<<"pos = "<<pos<<endl;
delete [] c;
c = NULL;
return max_len;
}
// test
int main()
{
const char *str1 = "abacaba";
const char *str2 = "tmallcabatmal";
int len1 = strlen(str1);
int len2 = strlen(str2);
char *lcs;
int len = LCS(str1 , len1 , str2 , len2 , lcs);
cout<<"max length = "<<len<<endl;
for(int i = 0 ; i < len ; ++i)
{
cout<<lcs[i];
}
cout<<"\n";
}// 最长公共子串（连续） LCS
#include <iostream>
#include <cstring>
#include <string.h>
using namespace std;
// 查找公共子串
// lcs记录公共子串
// return 公共子串长度
char* LCS(const char *str1, int len1, const char *str2, const int len2)
{
if(NULL == str1 || NULL == str2)
{
return NULL; //空参数
}
// 压缩后的最长子串记录向量
int i, *c = new int[len2+1];
for( i = 0 ; i < len2 ; ++i)
{
c[i] = 0;
}
int max_len = 0; //匹配的长度
int pos = 0; //在str2上的匹配最末位置
for( i = 0 ; i < len1 ; ++i)
{
for(int j = len2 ; j > 0 ; --j) //更新时从后往前遍历
{
if(str1[i] == str2[j-1])
{
c[j] = c[j-1] + 1;
if(c[j] > max_len)
{
max_len = c[j];
pos = j-1;
}
}
else
{
c[j] = 0;
}
}
}
// 得到公共子串
char *lcs = new char[max_len];
for( i = 0 ; i < max_len ; ++i)
{
lcs[i] = str2[pos-max_len+1+i];
}
lcs[i] = '\0';
delete [] c;
c = NULL;
return lcs;
}
// test
int main()
{
const char *str1 = "abacaba";
const char *str2 = "tmallcabatmal";
int len1 = strlen(str1);
int len2 = strlen(str2);
char *str = LCS(str1 , len1 , str2 , len2);
printf("%s\n", str);
return 0;
}2.实现一个程序，从键盘输入两个字符串，连接两个字符串，并去掉其重复子串，输入的字符串中只能是字符和空格，字符串以空格进行分割.
例：输入两个字符串如下:
"what is your name"
"my name is bourne"
则去掉两个字符串中都包含的is和name输入: "what your my bourne"；
第一题参考代码：
#include "stdio.h"
#include "malloc.h"
#include "string.h"
char *maxsubstr(char *str1, char *str2)
{
char *p1, *p2, *q1, *q2, *destp;
char *substr;
int max = 0, len;
p1 = str1;
while(*p1 != '\0')
{
q1 = str2;
while(*q1 != '\0')
{
len = 0;
p2 = p1;
q2 = q1;
while((*p2 != '\0')&&(*q2 != '\0'))
{
if(*p2 == *q2)
{
p2 ++;q2 ++;len ++;
}
else
{
break;
}
}
if(len > max)
{
max = len;
destp =p1;
}
q1++;
}
p1++;
}
substr=(char*)malloc(sizeof(char)*max);
strncpy(substr,destp,max);
substr[max] = '\0';
return substr;
}
int main()
{
char *s1="aocdfe";
char *s2="pmcdfa";
char *sub;
printf("%s\n%s\n",s1,s2);
sub = maxsubstr(s1,s2);
printf("the max sub string is:%s\n",sub);
return 0;
}
第二题参考代码：
代码一：
#include "stdio.h"
#include "string.h"
#define N 4
void lookup_keyword(char *desired_word[],char *keyword_table[],int a[],int b[],int *m,int *n )
{
int i,j;
int aCount = 0,bCount = 0;
for(j = 0;j < N;j ++)
{
for(i = 0;i < N;i ++)
{
if(strcmp(keyword_table[j],desired_word[i]) == 0)
{
a[aCount ++] = i;
b[bCount ++] = j;
}
}
}
*m = aCount;
*n = bCount;
}
int main(int argc, char* argv[])
{
char *a_table[N] = {"what","is","you","name"};
char *b_table[N] = {"my","name","is","tom"};
int a[N],b[N];
int i,j,m,n,tag;
lookup_keyword(a_table,b_table,a,b,&m,&n );
//for(i =0;i<m;i++)
// printf("%2d",a[i]);
//printf("\n");
// for(i =0;i<n;i++)
// printf("%2d",b[i]);
//printf("\n");
// printf("%d,%d",m,n);
for(i = 0;i < N;i ++)
{
tag = 0;
for(j = 0;j < m;j ++)
{
if(i == a[j])
tag = 1;
}
if(tag == 0)
printf("%8s",a_table[i]);
}
for(i = 0;i < N;i ++)
{
tag = 0;
for(j =0;j < n;j ++)
{
if(i == b[j])
tag = 1;
}
if(tag == 0)
printf("%8s",b_table[i]);
}
printf("\n");
return 0;
}
代码二：
#include "stdio.h"
#include "string.h"
int lookup_keyword(char const* desired_word, const char *keyword_table[],int const size )
{
const char **p_kw;
/*
**对于表中的每个单词
*/
for( p_kw = keyword_table; p_kw < keyword_table + size; p_kw++ )
{
/*
**如果这个单词与我们所查找的单词匹配，返回它在表中的位置
*/
if( strcmp( desired_word, *p_kw ) == 0 )
{
return p_kw - keyword_table;
}
}
/*
**没有找到，返回-1
*/
return -1;
}
int main(int argc, char* argv[])
{
const char * keyword_table[5]={
"hello ",
"world ",
"i ",
"love ",
"you "
};
int temp = 0;
temp = lookup_keyword( "you ", &(keyword_table[0]), 5 );
if( -1 == temp )
{
printf( "no\n ");
return 0;
}
printf( "yes %d\n ", temp+1);
return 0;
}
扫一扫
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
