【左神算法笔记】基础提升-Manacher算法

问题：最长回文子串长度

例如122131221中最长回文子串长度为4

经典解法：

遍历每一个字符，向两边扩充并检查最长的回文子串

但是光这样不能找出偶数长度的回文子串

所以要改造成#1#2#2#1#3#1#2#2#1#

这个新字符串的最大回文子串长度除以2取整即得原字符串的最大回文子串长度

问题扩展：插入的特殊字符#需要是字符串中没出现的字符吗？

答：不需要。因为比较的时候永远是特殊字符与特殊字符比较是否相等，原字符串中的字符之间比较

经典解法时间复杂度：O($N^2$)

Manacher：O(N)

明确概念：回文直径+回文半径

例如：#1#2#1#的回文直径为7，回文半径为4

一个字符串中的每一个字符都有对应的回文直径和回文半径，我们要遍历所有字符，生成一个回文半径数组

在生成回文半径的过程中，维护一个变量R，记录已经生成的回文子串的最右边界；还维护一个变量C，记录回文子串的中心

例如：arr={#,1,#,2,#,1,#,···}

R和C初始为-1，代表越界位置

遍历开始

对于arr[0]==‘#’，回文范围是0~0，R<0，所以更新R为0，更新C为0

对于arr[1]==‘1’，回文范围是0~2，R<2，所以更新R为2，C为1

对于arr[2]==‘#’，回文范围是2~2，R=2，所以不更新R和C

···

只要生成了回文半径数组和R，C，就可以得到解

manacher算法就是对这个过程进行了基于暴力的优化

来到i位置，分情况确定回文半径和直径：

1、若i>R，也就是i是第一次来到得位置，则暴力向两边扩展，寻找以arr[i]为中心的子串的回文半径；上面例子中的0，1，3位置都是这种情况

2、若i<=R，可以优化，一定是以下的情况：

此时，i’和i关于C对称，以C为中心的回文子串边界为L和R

L      i'      C      i      R

i在R的左边，那么C一定在i的左边（反证想想，注意C是已经遍历过的位置），一定可以找到对应的L，也可以找到i关于C的对称点

上例中的2，4，5，6都是这样

下面根据i’的回文情况分类：

1）以i’为中心的回文子串完全在L到R的范围内，那么i的回文半径和i’的一样（L到R是关于C对称的，所以很显然），做到了不扩充i就直接得到了答案

2）以i’为中心的回文子串有一部分在[L,R]以外，例如：

(ab[cd e dcba) k abcd e dc]ft
   L   i'      C      i   R 

则以i为中心的回文子串的回文半径为R-i+1，不会再大了，又做到了不扩充i就直接得到了答案

3）以i’为中心的回文子串的左边界和L重合

如：

[(abc d cba) k abc d cba]
      i'     C     i

则以i为中心的回文子串最小范围已经是abc d cba，往外还需要暴力扩展

完毕

根据代码可分析时间复杂度为O(N)

    public static int manacher(String s) {
        if (s == null || s.length() == 0) return 0;
        char[] str = manacherString(s); // 1221->#1#2#2#1#
        int[] pArr = new int[str.length]; // 回文半径数组
        int R = -1, C = -1, max = Integer.MAX_VALUE; // R是回文右边界再往右一个位置，不同于笔记
        for (int i = 0; i < str.length; i++) {
            // 得到不用扩展就已经知道的以i为中心的回文区域
            // 大情况1：初始直径为1，需要往外暴力扩展
            // 小情况1：中心为i'的回文直径长度，不需要扩展
            // 小情况2：半径为R-i+1，不需要扩展
            // 小情况3：中心为i'的回文直径长度，还需要再扩展
            pArr[i] = R > i ? Math.min(pArr[2 * C - i], R - i) : 1;

            // 从上述最小回文区域往外扩展
            // 为了让代码简洁，以上所有情况都扩展（不需要扩展的两种情况，第一次扩展就失败）
            // 实际上只有两种情况需要扩展
            while (i + pArr[i] < str.length && i - pArr[i] > -1) {
                if (str[i + pArr[i]] == str[i - pArr[i]]) {
                    pArr[i]++;
                } else {
                    break;
                }
            }
            if (i + pArr[i] > R) {
                R = i + pArr[i];
                C = i;
            }
            max = Math.max(max, pArr[i]);
        }
            return max - 1; // 半径减1正好是原始s的回文子串长度（不用除以2了）
    }

    public static char[] manacherString(String s) {
        char[] charArr = s.toCharArray();
        char[] res = new char[s.length() * 2 + 1];
        int index = 0;
        for (int i = 0; i != res.length; i++) {
            res[i] = (i % 2) == 0 ? '#' : charArr[index++];
        }
        return res;
    }

回文半径数组可以用于很多问题