字符串中最长回文算法

最新推荐文章于 2025-03-02 23:20:45 发布

帅性而为1号

最新推荐文章于 2025-03-02 23:20:45 发布

阅读量424

点赞数

CC 4.0 BY-SA版权

分类专栏：算法

本文链接：https://blog.youkuaiyun.com/zhushuai1221/article/details/52079151

算法专栏收录该内容

31 篇文章

订阅专栏

解法一：

这是一个非常常见的java面试问题，要解决这个问题，首先，我们要确定解决问题的基本思路。

这里关键是要先找到回文的中间点位置，然后比较它左右位置的字符是否相同。例如12321，这里的中间点为3，然后依次比较两侧的字符2和1。如果回文长度为偶数，例如12333321，这里中间点为33，然后依次比较3,2,1。

public class LongestPalindromeFinder {
 
    public static void main(String[] args) {
        System.out.println(longestPalindromeString("1234"));
        System.out.println(longestPalindromeString("12321"));
        System.out.println(longestPalindromeString("9912321456"));
        System.out.println(longestPalindromeString("9912333321456"));
        System.out.println(longestPalindromeString("12145445499"));
    }
 
    /**
     * 此方法返回输入字符串中的最长回文
     * 
     * @param in
     * @return
     */
    public static String longestPalindromeString(String in) {
        char[] input = in.toCharArray();
        int longestPalindromeStart = 0;
        int longestPalindromeEnd = 0;
 
        for (int mid = 0; mid < input.length; mid++) {
            // for odd palindrom case like 12321, 3 will be the mid
            int left = mid-1;
            int right = mid+1;
            // we need to move in the left and right side by 1 place till they reach the end
            while (left >= 0 && right < input.length) {
                // below check to find out if its a palindrome
                if (input[left] == input[right]) {
                    // update global indexes only if this is the longest one till now
                    if (right - left > longestPalindromeEnd
                            - longestPalindromeStart) {
                        longestPalindromeStart = left;
                        longestPalindromeEnd = right;
                    }
                }
                left--;
                right++;
            }
            // for even palindrome, we need to have similar logic with mid size 2
            // for that we will start right from one extra place
            left = mid-1;
            right = mid + 2;// for example 12333321 when we choose 33 as mid
            while (left >= 0 && right < input.length)
            {
                if (input[left] == input[right]) {
                    if (right - left > longestPalindromeEnd
                            - longestPalindromeStart) {
                        longestPalindromeStart = left;
                        longestPalindromeEnd = right;
                    }
                }
                left--;
                right++;
            }
        }
        // we have the start and end indexes for longest palindrome now
        return in.substring(longestPalindromeStart, longestPalindromeEnd + 1);
    }
 
}
Output of the above program is:

1
2
3
4
5
1
12321
12321

解法二：

回文串定义：“回文串”是一个正读和反读都一样的字符串，比如“level”或者“noon”等等就是回文串。回文子串，顾名思义，即字符串中满足回文性质的子串。

经常有一些题目围绕回文子串进行讨论，比如POJ3974最长回文，求最长回文子串的长度。朴素算法是依次以每一个字符为中心向两侧进行扩展，显然这个复杂度是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[]值已经得到了，我们利用回文串的特殊性质可以进行一个大大的优化。

先把核心代码贴上：

for (i = 0; i < len; i++){  
         if (maxid > i){  
             p[i] = min(p[2*id - i], maxid - i);  
         }  
         else{  
              p[i] = 1;  
         }  
         while (newstr[i+p[i]] == newstr[i-p[i]])  
                p[i]++;  
         if (p[i] + i > maxid){  
             maxid = p[i] + i;  
             id = i;  
         }  
         if (ans < p[i])  
             ans = p[i];  
     }

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

if (maxid > i){  
             p[i] = min(p[2*id - i], maxid - i);  
         }

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

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)。

下面就贴一个具体代码，求解最长回文字符串的代码：

#include <iostream>  
#include <algorithm>  
#include <string>  
using namespace std;  
const int MAX = 100001;  
int len, p[2*MAX];  
char str[2*MAX], newstr[2*MAX];  
  
void change()  
{  
     int i;  
     newstr[0] = '@';  
     newstr[1] = '#';  
     for (i = 0; i < len; i++){  
         newstr[2*i + 2] = str[i];  
         newstr[2*i + 3] = '#';  
     }  
     newstr[2*len + 2] = '\0';  
     return ;  
}  
  
  
void Manacher()  
{  
     int i, j, id, maxid = 0, ans = 1;  
     len = 2 * len + 2;  
     for (i = 0; i < len; i++){  
         if (maxid > i){  
             p[i] = min(p[2*id - i], maxid - i);  
         }  
         else{  
              p[i] = 1;  
         }  
         while (newstr[i+p[i]] == newstr[i-p[i]])  
                p[i]++;  
         if (p[i] + i > maxid){  
             maxid = p[i] + i;  
             id = i;  
         }  
         if (ans < p[i])  
             ans = p[i];  
     }  
       
     for (i = id, j = 0; i < id + ans; i++){  
          if (newstr[i] != '#'){  
              str[j] = newstr[i];  
              j++;  
          }  
     }  
     str[id+ans] = '\0';  
     cout << ans - 1 << " " << str << endl;  
     return ;  
}  
  
  
int main()  
{  
    while (scanf("%s", &str)){  
          if (strcmp(str, "END") == 0)   break;  
          len = strlen(str);  
          change();  
          Manacher();  
    }  
      
    system("pause");  
}

解法三：

前面的算法考虑都是从联系对称的角度来说的，也就是说，从中间点位置开始寻找子串一直到找到最长子串这个过程中，组成最长子串的各个字符都是相邻的。但是如果中间有字符不相临呢？比如，那么我们就要考虑另外的办法。开始还是安照前面的方法从中间向两边扫描，然后如果出现不匹配的情况，记下不匹配的开始位置，然后继续扫描，直到出现再一次匹配，然后记下最后不匹配的位置，最后扫描完整个字符串。删除不匹配的段，剩下的就是所求。