Hiho 1032 最长回文子串

时间限制: 1000ms

单点时限: 1000ms

内存限制: 64MB

描述

   小Hi和小Ho是一对好朋友，出生在信息化社会的他们对编程产生了莫大的兴趣，他们约定好互相帮助，在编程的学习道路上一同前进。

   这一天，他们遇到了一连串的字符串，于是小Hi就向小Ho提出了那个经典的问题：“小Ho，你能不能分别在这些字符串中找到它们每一个的最长回文子串呢？”

   小Ho奇怪的问道：“什么叫做最长回文子串呢？”

   小Hi回答道：“一个字符串中连续的一段就是这个字符串的子串，而回文串指的是12421这种从前往后读和从后往前读一模一样的字符串，所以最长回文子串的意思就是这个字符串中最长的身为回文串的子串啦~”

   小Ho道：“原来如此！那么我该怎么得到这些字符串呢？我又应该怎么告诉你我所计算出的最长回文子串呢？

   小Hi笑着说道：“这个很容易啦，你只需要写一个程序，先从标准输入读取一个整数N（N<=30)，代表我给你的字符串的个数，然后接下来的就是我要给你的那N个字符串（字符串长度<=10^6)啦。而你要告诉我你的答案的话，只要将你计算出的最长回文子串的长度按照我给你的顺序依次输出到标准输出就可以了！你看这就是一个例子。”

样例输入

3
abababa
aaaabaa
acacdas

样例输出7
5

3

1. 动态规划，时间复杂度O(n2)

import java.util.Scanner;

/**
 * 最长回文子串
 */
public class Main{
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int n = scanner.nextInt();
        for (int i = 0; i < n; i++) {
            char[] s = scanner.next().toCharArray();
            int len = findLongestPalindrome(s);
            System.out.println(len);
        }
    }
    public static int findLongestPalindrome(char[] ch) {
        int n = ch.length;
        int maxLen = 0;
        int start = 0;
        boolean[][] dp = new boolean[n][n];
        for (int i = 0; i < n; i++) {
            dp[i][i] = true;
            if (i < n - 1 && ch[i] == ch[i+1]) {
                maxLen = 2;
                start = i;
                dp[i][i+1] = true;
            }
        }
        //子串长度为3
        for (int len = 3; len <= n; len++) {
            for (int i = 0; i < n - len + 1; i++) {
                //子串结束地址
                int j = i + len - 1;
                if (dp[i + 1][j - 1] && ch[i] == ch[j]) {
                    dp[i][j] = true;
                    maxLen = len;
                    start = i;
                }
            }
        }
        return maxLen;
    }
}

2. 中心扩展

中心扩展就是把给定的字符串的每一个字母当做中心，向两边扩展，这样来找最长的子回文串。算法复杂度为O(n^2).

public static int findLongestPalindrome(char[] ch) {
        int n = ch.length;
        int maxLen = 0;
        int start = 0;
        //长度为奇数
        for (int i = 0; i < n; i++) {
            int j = i - 1, k = i + 1;
            while ( j >= 0 && k < n && ch[j] == ch[k]) {
                int ans = k - j + 1;
                if (ans > maxLen) {
                    maxLen = ans;
                    start = j;
                }
                j--;
                k++;
            }
        }

        //长度为偶数
        for (int i = 0; i < n; i++) {
            int j = i, k = i + 1;
            while (j >=0 && k < n && ch[j] == ch[k]) {
                int ans = k - j + 1;
                if (ans > maxLen) {
                    maxLen = ans;
                    start = j;
                }
                j--;
                k++;
            }
        }
        return maxLen;
    }

3. Manacher法

public static int findLongestPalindrome(String s) {
        StringBuilder stringBuilder = new StringBuilder(s);

        int n = s.length();
        //预处理,给字符串添加"#"
        for (int i = 0, k = 0; i < n; i++) {
            stringBuilder.insert(k, "#");
            k += 2;
        }
        stringBuilder.append("#");
        char[] ch = stringBuilder.toString().toCharArray();
        n = ch.length;
        int[] RL = new int[n];
        int maxRight = 0;
        int pos = 0;
        int MaxLen = 0;
        for (int i = 0; i < n; i++) {
            if (i < maxRight)
                //2 * pos - i表示i关于pos的对称点
                RL[i] = Math.min(RL[2 * pos - i], maxRight - i);
            else
                RL[i] = 1;
            //尝试扩展，注意边界处理
            while (i - RL[i] >= 0 && i + RL[i] < n && ch[i - RL[i]] == ch[i + RL[i]])
                RL[i] += 1;
            //更新maxRight,pos
            if (RL[i] + i - 1 > maxRight) {
                maxRight = RL[i] + i - 1;
                pos = i;
            }

            //更新最长回文串的长度
            MaxLen = Math.max(MaxLen, RL[i]);
        }
        return MaxLen - 1;
    }