背景

最近开始研究算法，于是在leetcode上做算法题，第五题Longest Palindromic Substring便是关于回文子串的。

什么是回文字串

回文字符串是指将该字符串前后颠倒之后和该字符串一样的字符串。例如:a,aaaa,aba,abba…

最长回文子串

要求最长回文子串，就需要遍历每一个子串，时间复杂度是O(N2)；判断字串是不是回文，时间复杂度是O(N)，这样的话算法的时间复杂度就是O(N3).

我刚开始想到的就是中心扩展法，代码如下：

public static String getLongestPalindrome(String str) {
        if(str.isEmpty() || str.length() == 1) {
            return str;
        }

        String longest = str.substring(0, 1);
        for (int i = 0; i < str.length(); i++) {
            // get longest palindrome with center of i
            String tmp = helper(str, i, i);
            if (tmp.length() > longest.length()) {
                longest = tmp;
            }  

            // get longest palindrome with center of i, i+1
            tmp = helper(str, i, i + 1);
            if (tmp.length() > longest.length()) {
                longest = tmp;
            }
        }
        return longest;
    }

    private static String helper(String str, int begin, int end) {
        while (begin >= 0 && end <= str.length() - 1
                && str.charAt(begin) == str.charAt(end)) {
            begin--;
            end++;
        }
        String result = str.substring(begin + 1, end);
        return result;
    }

中心扩展法的时间复杂度为O(N2).

写完之后一直在想，有没有更厉害的办法呢，能将时间复杂度杀到O(N)呢，一直想也想不到，后来上网搜到了传说中的Manacher算法。

我们先来看一下代码：

public static int[] getPalindromeLength(String str) {
    	StringBuilder newStr = new StringBuilder();
    	newStr.append("#");
    	for(int i = 0; i < str.length(); i++) {
    		newStr.append(str.charAt(i));
    		newStr.append("#");
    	}

    	int[] rad = new int[newStr.length()];

    	// the right edge of the longest sub palindrome string
    	int right = -1;
    	// the center of the longest sub palindrome string
    	int id = -1;

    	for (int i = 0; i < newStr.length(); i++) {
    	    // define the minimum radius
    		int r = 1;
            if (i <= right) {
                r = Math.min(right - i, rad[2 * id - i]);
            }

            // try to get a lager radius
            while (i - r >= 0 && i + r < newStr.length()
            		&& newStr.charAt(i - r) == newStr.charAt(i + r)) {
                r++;
            }

            //update the right edge and the center of the longest sub palindrome string
            if (i + r - 1> right) {
                right = i + r - 1;
                id = i;
            }
            rad[i] = r;
    	}

    	return rad;
    }

首先，Manacher算法提供了一个巧妙解决长度为奇数与长度为偶数的不同回文办法，在每个字符见插入一个原字符串未出现过的特殊字符，一般情况下用“#”。这样不管是aba类型的回文还是abba类型的回文，插入特殊字符之后，#a#b#a#和#a#b#b#a#的长度肯定是奇数，这样就解决了上面的问题。

Manacher算法引入一个辅助数组来记录以每个字符为中心的最长回文串的信息，Rad[i]记录的是以字符str[i]为中心的最长回文串，当以str[i]为中心，这个最长回文串向两边延伸Rad[i]个字符。

原串：abbac

新串：#a#b#b#a#c#

辅助数组：12 1 2 5 2 1 2 1 2 1

那么Manacher算法是怎么计算辅助数组Rad的呢?

我们从左往右依次计算Rad[i]，当计算Rad[i]时，Rad[j](0<=j<i)已经计算完毕。我们假设整型right为当前最长回文子串的最右边缘，并且设当前最长回文子串的中心点为id，那么当前指针的位置i就有两种情况：

第一种：i<=right

那么找到i相对于中心点的对称的位置j(2*id-i)，那么如果Rad[j]<right-i，如下图：

那么说明以j为中心的回文串一定在以id为中心的回文串的内部，且j和i关于位置id对称，由回文串的定义可知，一个回文串反过来还是一个回文串，所以以i为中心的回文串的长度至少和以j为中心的回文串一样，即Rad[i]>=Rad[j]。因为Rad[j]<right-i，所以说i+Rad[j]<right。由对称性可知Rad[i]=Rad[j]。

如果Rad[j]>=right-i,由对称性，说明以i为中心的回文串可能会延伸到right之外，而大于right的部分我们还没有进行匹配，所以要从right+1位置开始一个一个进行匹配，直到发生失配，从而更新right和对应的id以及Rad[i]。

第二种情况：i>right

如果i比right还要大，说明对于中点为i的回文串还一点都没有匹配，这个时候，就只能老老实实地一个一个匹配了，匹配完成后要更新right的位置和对应的id以及Rad[i]。

总结

1．  Manacher算法先巧妙的在所有字符间插入特殊字符，很好的解决了回文字串偶数长度和奇数长度不同处理方法的问题。

2．  其实Manacher算法的复杂度不只O(N),但是显然是介于O(N)和O(N2)之间，是目前时间复杂度最低的回文子串算法。

版权声明：本文为博主原创文章，未经博主允许不得转载。