最长公共子串

代码实现:

public class LCS2 {
	public static int getLongestSubStr(String s1, String s2){
		int m = s1.length(), n = s2.length();
		int [][] matrix = new int[m][n];
		int max = 0;
		for(int i=0; i<m; i++){
			for(int j=0; j<n; j++){
				if(s1.charAt(i)==s2.charAt(j)){
					int tmp = 1;
					if(i>0&&j>0){
						tmp = matrix[i-1][j-1]+1;
					}
					if(max<tmp) max = tmp;
					matrix[i][j] = tmp;
				}else{
					matrix[i][j] = 0;
				}
			}
		}
		return max;
	}
	public static void main(String [] args){
		String s1 = "bab", s2 = "ebaccbaba";
		System.out.println(getLongestSubStr(s1, s2));
		int [] a = {1,2,3};
	}

}



下文转自:http://blog.csdn.net/steven30832/article/details/8260189

动态规划有一个经典问题是最长公共子序列,但是这里的子序列不要求连续,如果要求序列是连续的,我们叫公共子串,那应该如何得到这个串呢?


最简单的方法就是依次比较,以某个串为母串,然后生成另一个串的所有长度的子串,依次去母串中比较查找,这里可以采用先从最长的子串开始,减少比较次数,但是复杂度依然很高!


然后重新看一下这个问题,我们建立一个比较矩阵来比较两个字符串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行。


代码如下:

[cpp]  view plain copy
  1. //  最长公共子串(连续)  LCS  
  2. //  Deng Chao  
  3. //  2012.12.4  
  4.   
  5. #include <iostream>  
  6. #include <cstring>  
  7. using namespace std;  
  8.   
  9.   
  10. //  查找公共子串  
  11. //  lcs记录公共子串  
  12. //  return  公共子串长度  
  13. int LCS(const char *str1  , int len1 , const char *str2 , int len2 , char *&lcs)  
  14. {  
  15.     if(NULL == str1 || NULL == str2)  
  16.     {  
  17.         return -1;  //空参数  
  18.     }  
  19.       
  20.     //  压缩后的最长子串记录向量  
  21.     int *c = new int[len2+1];  
  22.     for(int i = 0 ; i < len2 ; ++i)  
  23.     {  
  24.         c[i] = 0;  
  25.     }  
  26.     int max_len = 0;    //匹配的长度  
  27.     int pos = 0;        //在str2上的匹配最末位置  
  28.     for(int i = 0 ; i < len1 ; ++i)  
  29.     {  
  30.         for(int j = len2 ; j > 0 ; --j)  //更新时从后往前遍历  
  31.         {   
  32.             if(str1[i] == str2[j-1])  
  33.             {  
  34.                 c[j] = c[j-1] + 1;  
  35.                 if(c[j] > max_len)  
  36.                 {  
  37.                     max_len = c[j];  
  38.                     pos = j-1;  
  39.                 }  
  40.             }  
  41.             else  
  42.             {  
  43.                 c[j] = 0;  
  44.             }  
  45.         }  
  46.     }  
  47.       
  48.     if(0 == max_len)  
  49.     {  
  50.                 delete [] c;  
  51.         return 0;  
  52.     }  
  53.       
  54.     //  得到公共子串  
  55.     lcs = new char[max_len];  
  56.     for(int i = 0 ; i < max_len ; ++i)  
  57.     {  
  58.         lcs[i] = str2[pos-max_len+1+i];  
  59.     }  
  60.     cout<<"pos = "<<pos<<endl;  
  61.     delete [] c;  
  62.         delete [] lcs;  
  63.     return max_len;  
  64.       
  65. }  
  66.   
  67. //  test  
  68. int main()  
  69. {  
  70.     const char *str1 = "abacaba";  
  71.     const char *str2 = "caba";  
  72.     int len1 = strlen(str1);  
  73.     int len2 = strlen(str2);  
  74.       
  75.     char *lcs;  
  76.       
  77.     int len = LCS(str1 , len1 , str2 , len2 , lcs);  
  78.     cout<<"max length = "<<len<<endl;  
  79.     for(int i = 0 ; i < len ; ++i)  
  80.     {  
  81.         cout<<lcs[i]<<" ";  
  82.     }  
  83. }  

注意:

在更新最长子串长度的向量时,是从后往前遍历更新的,为什么???从前往后遍历更新会出现什么情况?


  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

WitsMakeMen

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

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

余额充值