【最长回文子串】Manacher算法

题目：LeetCode.5 最长回文子串

点击这里来查看题目来源。
给定一个字符串 s，找到 s 中最长的回文子串。你可以假设 s 的最大长度为 1000。

示例 1：

输入: "babad"
输出: "bab"
注意: "aba" 也是一个有效答案。

示例 2：

输入: "cbbd"
输出: "bb"

解法1：暴力法

定义l和r，用于表示回文的左边界和右边界。然后定义一个t在[l, r]之间扫描。
代码比较简单，效率较低，这里不写。
时间复杂度：O(n^3)，空间复杂度：O(1)。

解法2：DP法求解最长公共子串

我们可以很快的就想到将原有的字符串s翻转得到fs，然后得到二者的最长公共子串。需要注意一点，找到了之后还需要判断一下是否是回文串，因为可能会遇上"aacdefcaa"，其回文串是"aacfedcaa"，如果比较最长公共子串，得出结果是aac，不是正确答案，所以需要判断是否是回文。
在判断最长公共子串的时候可以用dp的方法来计算。
代码如下，时间复杂度：O(n^2)，空间复杂度O(n)。

class Solution {
    public String longestPalindrome(String s) {
        char[] cs = s.toCharArray();
        char[] fcs = filpChars(cs);
        int[] dp = new int[cs.length]; // 仅需要O(n)的空间就可以表示原有的O(n^2)的空间
        int pre = 0; // pre => dp[i - 1][j - 1]的状态
        int now; //now => dp[i][j]的状态
        int maxLen = 0, place = 0;

        for (int i = 0; i < cs.length; i++) {
            for (int j = 0; j < fcs.length; j++) {
            	// 前一个状态pre，如果行或列为0，前者状态肯定是0
                if (i == 0 || j == 0) pre = 0;
                // 计算当前的值
                if (cs[i] == fcs[j]) now = pre + 1;
                else now = 0;
                
                pre = dp[j]; // 更新pre
                dp[j] = now; // 更新dp[j]，必须在更新pre之后
                // 判断是否是有效的状态
                if (now > maxLen && checkPalindrome(fcs, j - now + 1, j)) {
                    maxLen = now;
                    place = j;
                }
            }
        }
        
        // 得出最终结果
        char[] ans = new char[maxLen];
        for (int i = place - maxLen + 1, j = 0; i < place + 1; i++, j++)
            ans[j] = fcs[i];
        
        return new String(ans);
    }
    
    // 翻转字符串
    public char[] filpChars(char[] cs) {
        char[] fcs = new char[cs.length];
        for (int l = 0, r = cs.length - 1; l < fcs.length; l++, r--)
            fcs[l] = cs[r];
        return fcs;
    }
    
    // 检查是否是回文
    public boolean checkPalindrome(char[] c, int l, int r) {
        while (l < r) if (c[l++] != c[r--]) return false;
        return true;
    }
}

解法3：Manacher算法

点击这里来查看英文原文。由于本人能力有限，有可能会出现词不达意的情况，这里贴出原文，大家可以互相参考。

我们现在的目标是改进原有的O(n^2)时间复杂度。原先的情况中，最糟糕的情况是多个回文相互重叠的输入，例如，输入："aaaaaaaaa"和"cabcbabcbabcba"。实际上，我们可以利用回文的对称属性并避免一些不必要的计算。
首先，我们通过在字母之间插入一个特殊字符'＃'将输入字符串S转换为另一个字符串T，如"abc"=>"#a#b#c#"。这样做的原因很快就会清楚。
为了找到最长的回文子串，我们需要在Ti的周围扩展，使得在区间[T(i - d), T(i + d)]的字符串形成回文。我们可以很清晰的了解，d是以Ti为中心的回文的长度。
我们将中间结果存储在数组P中，其中P[i]等于Ti处的回文中心的长度。最长的回文子串将是P中的最大元素。

使用上面的例子，我们填充P如下（从左到右）：

T = # a # b # a # a # b # a #
P = 0 1 0 3 0 1 6 1 0 3 0 1 0

现在观察一下P，一下子就能够发现最长的回文是"abaaba"，即P6 = 6所代表的含义。
如果你观察的足够仔细，你会发现不管是奇数还是偶数的回文长度，在这里都能够得到结果。

现在，想象一下你在回文"abaaba"的中心画一条想象的垂直线。您是否注意到P中的数字是围绕该中心对称的？不仅如此，尝试另一个回文"aba"，这些数字(p[i]的值)也反映出类似的对称属性。这是巧合吗？答案是肯定的，不是。这是有条件的，但无论如何，我们已经有了很大的进步，因为我们可以消除重新计算P[i]的部分。

让我们继续进行一个稍微复杂的例子，其中有一些重叠的回文，其中S = "babcbabcbaccba"。

上图的T是从S = "babcbabcbaccba"中转换而来。假设您已达到表P当前的状态。实线垂直线表示回文"abcbabcba"的中心（C）。两条虚线垂直线分别表示其左（L）和右（R）边缘。当前的索引在i，它在C周围的镜像索引是i'。你如何有效的计算P[i]？
假设我们已经到达i = 13，我们需要计算P[13]（由问号？表示）。我们首先看一下它在回文的中心C周围的镜像索引，即索引i' = 9。

上面的两条绿色实线表示以i和i'为中心的两个回文区域的覆盖区域。我们看看C周围的镜像索引，即索引i'。P[i'] = P[9] = 1.很明显P[i]也必须是1，这是由于回文的中心周围的对称性质。
正如您在上面所看到的，很明显P[i] = P[i'] = 1，由于围绕回文中心的对称性，它必须是真的。事实上，C之后的所有三个元素都遵循对称性（即P[12] = P[10] = 0，P[13] = P[9] = 1，P[14] = P[8] = 0）。

现在我们在索引i = 15，它关于C的镜像索引i'= 7。你认为P[15] = P[7] = 7吗？
现在我们在索引i = 15，请问P[i]的值是多少？如果我们遵循对称属性，P[i]的值应该与P[i'] = 7相同。但这是错误的。如果我们在T[15]处围绕中心扩展，它形成了一个回文"a＃b＃c＃b＃a"，它比我们刚刚提出的p[i'] = 7要小。为什么？

在索引i和i'处围绕中心重叠彩色线。由于C周围的对称属性，绿色实线显示两侧必须匹配的区域。红色实线表示两侧可能不匹配的区域。虚线绿线表示穿过中心的区域。
很明显，由两条实线绿线表示的区域中的两个子串必须完全匹配。中心区域（由绿色虚线表示）也肯定是对称的。仔细注意P[i']是7并且它一直延伸到回文的左边缘（L）（由实线红线表示），它不再处于在回文的对称性质之下。我们所知道的是P[i] ≥ 5，为了找到P[i]的实数值，我们必须通过扩展经过右边缘（R）来进行字符匹配。在这种情况下，由于P[21] ≠ P[1]，我们得出结论P[i] = 5。

让我们总结一下这个算法的关键部分如下：

如果 P[i'] ≤ R-i
那么 p[i'] => p[i]
否则 P[i] ≥ P[i']。 // 我们必须扩展经过右边缘（R）才能找到P[i]。

如果你能够完全掌握上述关键伪代码，你就已经获得了这个算法的本质，这也是最难的部分。

最后一部分是确定我们何时应将C的位置与R一起向右移动，这很容易：

如果以i为中心的回文确实扩展到R，我们将C更新为i（这个新回文的中心），并将R扩展到新回文的右边缘。

在每个步骤中，有两种可能性。如果P[i] ≤ R - i，我们将P[i]设置为P[i']，它只需要一步。否则，我们尝试通过从右边缘R开始扩展它来将回文的中心改为i。扩展R（内部回路）最多总共需要N步，定位和测试每个中心总共需要N步。因此，该算法保证最多完成2 * N步，即线性时间解。
以下是Java的实现代码。时间复杂度：O(n)，空间复杂度：O(n)。

class Solution {
    public String longestPalindrome(String s) {
        String t = preProcess(s);

        int[] p = new int[t.length()];
        int center = 0, right = 0, ansCenter = 0, ansLen = 0;
        for (int i = 1; i < t.length() - 1; i++) {
            int iMirror = 2 * center - i; // i的镜像：i` = center - (i - center)
            p[i] = (right > i) ? Math.min(right - i, p[iMirror]) : 0;
            
            // 试图扩大以i为中心的回文数据
            while (t.charAt(i - 1 - p[i]) == t.charAt(i + 1 + p[i])) p[i]++;
            
            // 如果以i为中心的回文的右边界超过了R，则将新的中心调整为新的回文的中心。
            if (i + p[i] > right) {
                center = i;
                right = i + p[i];
            }
            
            //找到P中的最大元素
            if (p[i] > ansLen) {
                ansLen = p[i];
                ansCenter = i;
            }
        }
        return s.substring((ansCenter - ansLen - 1) / 2, (ansCenter + ansLen - 1) / 2);
    }
    
    /**
     * 将S转换为T.
     * 例如，S ="abba"，T ="^#a＃b＃b＃a＃$"。
     * ^和$符号是附加到每一端的标记，以避免边界检查
     */
    public String preProcess(String s) {
        if (s.length() == 0) return "^$";
        char[] cs = new char[s.length() * 2 + 3];
        cs[0] = '^';
        for (int i = 0; i < s.length(); i++) {
            cs[i * 2 + 2] = s.charAt(i);
            cs[i * 2 + 1] = '#';
        }
        cs[cs.length - 2] = '#';
        cs[cs.length - 1] = '$';
        return new String(cs);
    }
}