程序员面试100题之七：最长公共子字符串

子字符串的定义和子序列的定义类似，但要求是连续分布在其他字符串中。比如输入两个字符串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

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. }  

        效果图如下：

方法二：

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

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

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

      完整的代码如下：

[cpp] view plain copy

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. }  

      效果图如下：

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

[cpp] view plain copy

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. }  

       效果图如下：

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

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

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

        rose
       orchid 

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

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

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

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

[cpp] view plain copy

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. }