Manacher算法

又名“马拉车”算法。

前提假设

引出这个算法需要设想这样的一个题目：求一个字符串的最大回文子串。

注意：子序列和子串的区别 ababd的子序列之一是aad，ababd的子串就不可以是aad，因为没有在一起

经典解法

添加虚拟节点

将字符串122131变成#1#2#2#1#3#1，然后以第一个点为轴左右进行比较看看回文，以第二个点为轴左右进行比较看看回文，。。。然后得到的数字进行/2操作，向下取整，最大的就是最长的回文序列。

注意：添加的虚拟节点可以是任意符号，都不会影响结果。因为最后都进行/2操作了。

复杂度分析

时间复杂度计算：按最差的全是1111111…111进行，这样相当于左边一个等差数列、右边一个等差数列，所以是O(N^2)。

Manacher算法细节

相关定义

最右回文右边界：回文右边界指各个节点可以向右扩充的最大程度，表示是各个节点的最大右边界(即(轴心位置 + 回文半径)的位置)，初始值设为-1，当然如果没有超过当前的最大回文右边界则没办法更新。为int型，int R。

更新轴心：设为一个int值C，只记录让回文右边界更新时（变大时）字符的轴心

回文半径数组：记录每个字符的回文半径

举例子

优化方案

情况1

当前来的字符点的位置没有在最右回文右边界R里面，只能暴力扩，没法优化

///

情况2

字符在最右回文右边界R里，此时进行下一个点i(还没更新R时)，此时C（上一个字符轴心，也是还没
更新前）在i左边，R在i右边,做出i的对称点i’,以及R的对称点L

///

情况2.1

i’的回文彻底在L、R的内部，此时i的回文数就是i’的回文数

///

情况2.2

i’的回文跑到了L、R的外部,那么i的回文半径就是R-i

///

情况2.3

压线，此时i的回文半径至少是R-i,但是可能会变得更远，需要去试

///

相关伪代码

• pArr[] 是回文半径数组

复杂度分析

扩失败的代价

如果只循环一次：

1. 循环的第一个分支最多失败一次
2. 循环的第二个分支，不会失败
3. 循环的第三个分支，不会失败
4. 循环的第四个分支，最多失败一次（可能成功很多次，但是有一次不匹配就会退出循环，i++）
   失败的时间复杂度是O（N）

扩成功的代价

如果只循环一次：

1. 循环的第一个分支向两边扩，R变大，然后i++
2. 循环的第二个分支，R不变，i++
3. 循环的第三个分支，R不变，i++
4. 循环的第四个分支，扩成功R变大，i++

故算上失败时与成功时整体的时间复杂度是O（N）

代码实现

    public static char[] manacherString(String str){
        //将字符串转化为char类型数组
        char[] charArr = str.toCharArray();
        //准备数组,并准备添加虚拟节点
        char[] res = new char[str.length() * 2 + 1];
        int index = 0;
        //添加虚拟数组
        for (int i = 0; i != res.length; i++){
            //利用奇偶性添加
            res[i] = (i & 1) == 0 ? '#' : charArr[index++];
        }
        return res;
    }

    //最大的回文子串
    public static int maxLcpsLength(String str){
        if (str == null || str.length() == 0){
            return 0;
        }
        //调用将字符串转化为添加虚拟节点后的字符型数组方法
        char[] charArr = manacherString(str);
        //pArr[] 是回文半径数组
        int[] pArr = new int[charArr.length];
        //注意这里的R和上面讲的略有不同，这里的R指的是回文右边界的再往右一个位置
        //也就是说最右的有效区是R - 1的位置，但是思想是一样的
        int R = -1;
        //达到最右回文右边界的轴心节点初始值设为-1
        int C = -1;
        //记录最大回文半径
        int max = Integer.MIN_VALUE;
        for (int i = 0; i != charArr.length; i++){
            //i位置至少的回文区域，先给pArr[i]
            //如果i >= R，（注意这里的R和上面讲的略有不同，这里的R指的是回文右边界的再往右一个位置）
            //则表示i完全在外面，所以只有本身的值是满足回文数的，所以此时回文半径是1
            //如果i < R,则表示压线或者小于，所以取R-i和pArr[i']的最小值
            pArr[i] = R > i ? Math.min(pArr[2 * C - i], R - i) : 1;
            //这里和上面讲解的伪代码不太一样，是知道它至少的回文区域后，都判断一下左右相邻的，
            //即使是压线或者在内部，那么他们也会一下子就break,不会影响时间复杂度。
            //如果左边和右边都不越界
            while (i + pArr[i] < charArr.length && i - pArr[i] > -1){
                if (charArr[i + pArr[i]] == charArr[i - pArr[i]]){
                    pArr[i]++;
                }else {
                    break;
                }
            }
            //更新R、C
            if (i + pArr[i] > R){
                R = i + pArr[i];
                C = i;
            }
            //max保存最大的回文半径
            max = Math.max(max, pArr[i]);
        }
        //#a#b#a# 如果这个是最大的回文长度，则知b的回文半径是4，我们分析得知最大的子串长度是abc,
        //所以知道两者关系最大回文半径4 - 1 = 3
        return max - 1;
    }

    public static void main(String[] args) {
        String str1 = "abc1234321ab";
        System.out.println(maxLcpsLength(str1));
    }