程序员面试100题之一：对称字符串的最大长度

题目：输入一个字符串，输出该字符串中对称的子字符串的最大长度。比如输入字符串“google”，由于该字符串里最长的对称子字符串是“goog”，因此输出4。

分析：可能很多人都写过判断一个字符串是不是对称的函数，这个题目可以看成是该函数的加强版。

要判断一个字符串是不是对称的，不是一件很难的事情。我们可以先得到字符串首尾两个字符，判断是不是相等。如果不相等，那该字符串肯定不是对称的。否则我们接着判断里面的两个字符是不是相等，以此类推。基于这个思路，我们不难写出如下代码：

[cpp] view plaincopy

1. /* 
2. 判断起始指针为pBegin，结束指针为pEnd的字符串是否对称 
3. */  
4. bool IsSymmetrical(char* pBegin, char* pEnd)  
5. {  
6.     if(pBegin == NULL || pEnd == NULL || pBegin > pEnd)  
7.         return false;  
8.     while(pBegin < pEnd)  
9.     {  
10.         if(*pBegin != *pEnd)  
11.             return false;  
12.         pBegin++;  
13.         pEnd --;  
14.     }  
15.     return true;  
16. }  

        要判断一个字符串pString是不是对称的，我们只需要调用IsSymmetrical(pString, &pString[strlen(pString) – 1])就可以了。

        现在我们试着来得到对称子字符串的最大长度。最直观的做法就是得到输入字符串的所有子字符串，并逐个判断是不是对称的。如果一个子字符串是对称的，我们就得到它的长度。这样经过比较，就能得到最长的对称子字符串的长度了。于是，我们可以写出如下代码：

[cpp] view plaincopy

1. /* 
2. 取得所有对称子串的最大长度 
3. 时间复杂度： O(n^3) 
4. */  
5. int GetLongestSymmetricalLength_1(char* pString)  
6. {  
7.     if(pString == NULL)  
8.         return 0;  
9.     int symmeticalLength = 1;  
10.     char* pFirst = pString;  
11.     int length = strlen(pString);  
12.   
13.     while(pFirst < &pString[length - 1])  
14.     {  
15.         char* pLast = pFirst + 1;  
16.         while(pLast <= &pString[length - 1])  
17.         {  
18.             if(IsSymmetrical(pFirst, pLast))  
19.             {  
20.                 int newLength = pLast - pFirst + 1;  
21.                 if(newLength > symmeticalLength)  
22.                     symmeticalLength = newLength;                            
23.             }  
24.             pLast++;  
25.         }  
26.         pFirst++;  
27.     }  
28.     return symmeticalLength;  
29. }  

         我们来分析一下上述方法的时间效率。由于我们需要两重while循环，每重循环需要O（n）的时间。另外，我们在循环中调用了IsSymmetrical，每次调用也需要O（n）的时间。因此整个函数的时间效率是O（n^3）。

        通常O（n^3）不会是一个高效的算法。如果我们仔细分析上述方法的比较过程，我们就能发现其中有很多重复的比较。假设我们需要判断一个子字符串具有aAa的形式（A是aAa的子字符串，可能含有多个字符）。我们先把pFirst指向最前面的字符a，把pLast指向最后面的字符a，由于两个字符相同，我们在IsSymtical函数内部向后移动pFirst，向前移动pLast，以判断A是不是对称的。接下来若干步骤之后，由于A也是输入字符串的一个子字符串，我们需要再一次判断它是不是对称的。也就是说，我们重复多次地在判断A是不是对称的。

        造成上述重复比较的根源在于IsSymmetrical的比较是从外向里进行的。在判断aAa是不是对称的时候，我们不知道A是不是对称的，因此需要花费O（n）的时间来判断。下次我们判断A是不是对称的时候，我们仍然需要O（n）的时间。

        如果我们换一种思路，我们从里向外来判断。也就是我们先判断子字符串A是不是对称的。如果A不是对称的，那么向该子字符串两端各延长一个字符得到的字符串肯定不是对称的。如果A对称，那么我们只需要判断A两端延长的一个字符是不是相等的，如果相等，则延长后的字符串是对称的。因此在知道A是否对称之后，只需要O（1）的时间就能知道aAa是不是对称的。

       我们可以根据从里向外比较的思路写出如下代码：

[cpp] view plaincopy

1. /* 
2. 取得所有对称子串的最大长度 
3. 时间复杂度： O(n^2) 
4. */  
5.   
6. int GetLongestSymmetricalLength(char* pString)  
7. {  
8.     if(pString == NULL)  
9.         return 0;  
10.     int symmeticalLength = 1;  
11.     char* pChar = pString;  
12.     while(*pChar != '\0')  
13.     {  
14.         // Substrings with odd length  
15.         char* left = pChar - 1;  
16.         char* right = pChar + 1;  
17.         while(left >= pString && *right != '\0' && *left == *right)  
18.         {  
19.             left--;  
20.             right++;  
21.         }  
22.         int newLength = right - left - 1;    //退出while循环时，*left != *right  
23.         if(newLength > symmeticalLength)  
24.             symmeticalLength = newLength;   
25.   
26.         // Substrings with even length  
27.         left = pChar;  
28.         right = pChar + 1;  
29.         while(left >= pString && *right != '\0' && *left == *right)  
30.         {  
31.             left--;  
32.             right++;  
33.   
34.         }  
35.         newLength = right - left - 1;        //退出while循环时，*left != *right  
36.         if(newLength > symmeticalLength)  
37.             symmeticalLength = newLength;  
38.         pChar++;  
39.     }  
40.     return symmeticalLength;  
41. }  

        由于子字符串的长度可能是奇数也可能是偶数。长度是奇数的字符串是从只有一个字符的中心向两端延长出来，而长度为偶数的字符串是从一个有两个字符的中心向两端延长出来。因此我们的代码要把这种情况都考虑进去。

       在上述代码中，我们从字符串的每个字符串两端开始延长，如果当前的子字符串是对称的，再判断延长之后的字符串是不是对称的。由于总共有O（n）个字符，每个字符可能延长O（n）次，每次延长时只需要O（1）就能判断出是不是对称的，因此整个函数的时间效率是O（n^2）。

 

回文串定义：“回文串”是一个正读和反读都一样的字符串，比如“level”或者“noon”等等就是回文串。
回文子串，顾名思义，即字符串中满足回文性质的子串。
经常有一些题目围绕回文子串进行讨论，比如 HDOJ_3068_最长回文，求最长回文子串的长度。朴素算法是依次以每一个字符为中心向两侧进行扩展，显然这个复杂度是O(N^2)的，关于字符串的题目常用的算法有KMP、后缀数组、AC自动机，这道题目利用扩展KMP可以解答，其时间复杂度也很快O(N*logN)。但是，今天笔者介绍一个专门针对回文子串的算法，其时间复杂度为O(n)，这就是manacher算法。
大家都知道，求回文串时需要判断其奇偶性，也就是求aba和abba的算法略有差距。然而，这个算法做了一个简单的处理，很巧妙地把奇数长度回文串与偶数长度回文串统一考虑，也就是在每个相邻的字符之间插入一个分隔符，串的首尾也要加，当然这个分隔符不能再原串中出现，一般可以用‘#’或者‘$’等字符。例如：
原串：abaab
新串：#a#b#a#a#b#
这样一来，原来的奇数长度回文串还是奇数长度，偶数长度的也变成以‘#’为中心的奇数回文串了。
接下来就是算法的中心思想，用一个辅助数组P记录以每个字符为中心的最长回文半径，也就是P[i]记录以Str[i]字符为中心的最长回文串半径。P[i]最小为1，此时回文串为Str[i]本身。
我们可以对上述例子写出其P数组，如下
新串： # a # b # a # a # b #
P[]  :  1 2 1 4 1 2 5 2 1 2 1
我们可以证明P[i]-1就是以Str[i]为中心的回文串在原串当中的长度。
证明：
1、显然L=2*P[i]-1即为新串中以Str[i]为中心最长回文串长度。
2、以Str[i]为中心的回文串一定是以#开头和结尾的，例如“#b#b#”或“#b#a#b#”所以L减去最前或者最后的‘#’字符就是原串中长度的二倍，即原串长度为(L-1)/2，化简的P[i]-1。得证。
依次从前往后求得P数组就可以了，这里用到了DP(动态规划)的思想，也就是求P[i]的时候，前面的P[]值已经得到了，我们利用回文串的特殊性质可以进行一个大大的优化。我先把核心代码贴上：

[cpp] view plaincopy

1. for(i=1;i<n;i++)  
2. {  
3.     if(MaxId>i)  
4.     {  
5.         p[i]=Min(p[2*id-i],MaxId-i);  
6.     }  
7.     else  
8.     {  
9.         p[i]=1;  
10.     }  
11.     while(Str[i+p[i]]==Str[i-p[i]])  
12.     {  
13.         p[i]++;  
14.     }  
15.     if(p[i]+i>MaxId)  
16.     {  
17.         MaxId=p[i]+i;  
18.         id=i;  
19.     }  
20. }  

为了防止求P[i]向两边扩展时可能数组越界，我们需要在数组最前面和最后面加一个特殊字符，令P[0]=‘$’最后位置默认为‘\0’不需要特殊处理。此外，我们用MaxId变量记录在求i之前的回文串中，延伸至最右端的位置，同时用id记录取这个MaxId的id值。通过下面这句话，算法避免了很多没必要的重复匹配。

[cpp] view plaincopy

1. if(MaxId>i)  
2. {  
3.     p[i]=Min(p[2*id-i],MaxId-i);  
4. }  

那么这句话是怎么得来的呢，其实就是利用了回文串的对称性，如下图：

j=2*id-1即为i关于id的对称点，根据对称性，P[j]的回文串也是可以对称到i这边的,但是如果P[j]的回文串对称过来以后超过MaxId的话，超出部分就不能对称过来了，如下图，所以这里P[i]为的下限为两者中的较小者，p[i]=Min(p[2*id-i],MaxId-i)。

算法的有效比较次数为MaxId次，所以说这个算法的时间复杂度为O(n)。
附HDOJ_3068_最长回文代码：

[cpp] view plaincopy

1. #include <stdio.h>  
2.   
3. #define M 110010  
4.   
5. char b[M],a[M<<1];  
6. int p[M<<1];  
7.   
8. int Min(int a,int b)  
9. {  
10.     return a<b?a:b;  
11. }  
12.   
13. int main(void)  
14. {  
15.     int i,n,id,MaxL,MaxId;  
16.     while(scanf("%s",&b[1])!=EOF)  
17.     {  
18.         MaxL=MaxId=0;  
19.         for(i=1;b[i]!='\0';i++)  
20.         {  
21.             a[(i<<1)]=b[i];  
22.             a[(i<<1)+1]='#';  
23.         }  
24.         a[0]='?';a[1]='#';  
25.         n=(i<<1)+2;a[n]=0;  
26.         MaxId=MaxL=0;  
27.         for(i=1;i<n;i++)  
28.         {  
29.             if(MaxId>i)  
30.             {  
31.                 p[i]=Min(p[2*id-i],MaxId-i);  
32.             }  
33.             else  
34.             {  
35.                 p[i]=1;  
36.             }  
37.             while(a[i+p[i]]==a[i-p[i]])  
38.             {  
39.                 p[i]++;  
40.             }  
41.             if(p[i]+i>MaxId)  
42.             {  
43.                 MaxId=p[i]+i;  
44.                 id=i;  
45.             }  
46.             if(p[i]>MaxL)  
47.             {  
48.                 MaxL=p[i];  
49.             }  
50.         }  
51.         printf("%d\n",MaxL-1);  
52.     }  
53.     return 0;  
54. }