[学习笔记] manacher 算法

1. 算法概述

Manacher算法是一种用于查找字符串中最长回文子串的线性时间复杂度算法。由Glenn Manacher于1975年提出，它巧妙地利用了回文串的对称性质来避免不必要的重复计算。

1.1 传统方法的问题

传统的中心扩展法需要 \(\mathcal{O}(n^2)\) 时间复杂度，因为它对每个字符都作为中心向两边扩展检查回文。Manacher算法通过记录之前计算的信息，将时间复杂度优化到 \(\mathcal{O}(n)\)。

2. 算法预处理

Manacher算法首先对原始字符串进行预处理，解决奇偶长度回文的问题。

2.1 插入特殊字符

我们在每个字符之间插入一个特殊字符（通常用 #，只要不混淆就行），并在首尾也插入特殊字符。

例如：

原始字符串: abba

预处理后: #a#b#b#a#

这样处理后，所有回文子串都变为奇数长度，统一了处理方式。

2.2 C++预处理实现

string preProcess(const string& s) {
    int n = s.length();
    if (n == 0) return "^$";
    string result = "^";
    for (int i = 0; i < n; i++) {
        result += "#" + s.substr(i, 1);
    }
    result += "#$";
    return result;
}

3. 核心概念

3.1 回文半径数组P

定义数组 \(P\)，其中 \(P_i\) 表示以 \(i\) 为中心的回文串的半径（包括中心自身）。

例如：

	1	2	3	4	5	6	7	8	9	10	11
处理后的字符串 \(T\)	^	#	a	#	b	#	b	#	a	#	$
\(P\) 数组	\(0\)	\(0\)	\(1\)	\(0\)	\(1\)	\(4\)	\(1\)	\(0\)	\(1\)	\(0\)	\(0\)

3.2 中心C和右边界 \(R\)

• \(C\): 当前已知的回文串的中心位置。
• \(R\): 当前已知的回文串的右边界位置 \((C + P_C)\)。

4. 算法流程

4.1 初始化

• C = 0, R = 0。
• \(P\) 数组全部初始化为 \(0\)。

4.2 主要步骤

对于每个 \(i\) 从 \(1\) 到 \(n-1\)：

1. 计算 \(i\) 关于C的镜像 \(i\_mirror = 2\cdot C - i\)。
2. 如果 \(i < R\)，则 \(P_i = \min(R-i, P_{i\_mirror})\)。
3. 尝试扩展以i为中心的回文串。
4. 如果 \(i + P_i > R\)，更新 \(C\) 和 \(R\)。

4.3 C++实现

vector<int> manacher(const string& s) {
    string T = preProcess(s);
    int n = T.length();
    vector<int> P(n, 0);
    int C = 0, R = 0;
    for (int i = 1; i < n-1; i++) {
        int i_mirror = 2 * C - i; // 计算i关于C的对称点
        if (R > i)
            P[i] = min(R - i, P[i_mirror]);
        else
            P[i] = 0;
        // 尝试扩展以i为中心的回文
        while (T[i + 1 + P[i]] == T[i - 1 - P[i]])
            P[i]++;
        // 如果扩展后的回文右边界超过R，更新中心和右边界
        if (i + P[i] > R) {
            C = i;
            R = i + P[i];
        }
    }
    return P;
}

5. 获取最长回文子串

5.1 从P数组中提取信息

• 最长回文长度 = \(\max(P_i)\)。
• 中心位置 = \(argmax(P_i)\)。

5.2 C++实现

string longestPalindrome(const string& s) {
    vector<int> P = manacher(s);
    int max_len = 0;
    int center_index = 0;
    for (int i = 1; i < P.size()-1; i++) {
        if (P[i] > max_len) {
            max_len = P[i];
            center_index = i;
        }
    }
    int start = (center_index - max_len) / 2;
    return s.substr(start, max_len);
}

6. 复杂度分析

6.1 时间复杂度

• 预处理: \(\mathcal{O}(n)\)。
• 主算法: \(\mathcal{O}(n)\) (因为while循环的扩展操作总共不会超过 \(n\) 次)。
• 总时间复杂度: \(\mathcal{O}(n)\)。

6.2 空间复杂度

• 需要 \(\mathcal{O}(n)\) 空间存储P数组。
• 预处理字符串需要 \(\mathcal{O}(n)\) 空间。
• 总空间复杂度: \(\mathcal{O}(n)\)。

7. 算法正确性证明

Manacher 算法的正确性基于以下观察：

1. 对称性质：回文串的对称性意味着我们可以利用已经计算过的信息。
2. 边界控制：通过维护当前最右边界 \(R\)，避免了重复计算。
3. 线性扩展：每次扩展要么直接利用对称点信息，要么从 \(R\) 开始扩展，确保不重复。

8. 边界情况处理

8.1 空字符串

预处理后变为 ^$，\(P\) 数组为[0,0]，返回空字符串。

8.2 单字符字符串

预处理后变为" ^#a#$，P数组为[0,0,1,0,0]，返回该字符。

8.3 全相同字符

如 aaaa，算法仍能高效处理，\(P\) 数组会线性增长。

9. 实际应用示例

9.1 示例运行

输入: cbbd

预处理后: ^#c#b#b#d#$

P数组计算过程：

i=1: \(P_1=0 (^#)\)

i=2: \(P_2=1 (#c#)\)

i=3: \(P_3=0 (b)\)

i=4: \(P_4=1 (#b#b#)\)

i=5: \(P_5=0 (b)\)

i=6: \(P_6=1 (#d#)\)

i=7: \(P_7=0 (\))$

最长回文长度为 \(1\)，对应原始字符串中的 bb。

10. 算法优化技巧

10.1 空间优化

可以只存储当前需要的部分P值，但实现会变得复杂。

10.2 预处理优化

可以使用原始字符串的2n+1长度数组，避免字符串拼接。

10.3 并行计算

某些步骤可以并行化，但通常不必要因为算法已经是线性。

11. 常见错误与调试

11.1 数组越界

在扩展回文时要检查边界：

while (i + 1 + P[i] < n && i - 1 - P[i] >= 0 &&
       T[i + 1 + P[i]] == T[i - 1 - P[i]]) {
    P[i]++;
}

11.2 初始值错误

确保 \(P\) 数组初始化为 \(0\)，\(C\) 和 \(R\) 初始化为 \(0\)。

11.3 预处理不当

确保预处理后的字符串首尾有不同字符（^和$），避免边界检查。

12. 完整测试代码

#include <iostream>
#include <vector>
#include <algorithm>

using namespace std;

string preProcess(const string& s) {
    int n = s.length();
    if (n == 0) return "^$";
    string result = "^";
    for (int i = 0; i < n; i++) {
        result += "#" + s.substr(i, 1);
    }
    result += "#$";
    return result;
}

vector<int> manacher(const string& s) {
    string T = preProcess(s);
    int n = T.length();
    vector<int> P(n, 0);
    int C = 0, R = 0;
    for (int i = 1; i < n-1; i++) {
        int i_mirror = 2 * C - i;
        if (R > i)
            P[i] = min(R - i, P[i_mirror]);
        else
            P[i] = 0;
        while (i + 1 + P[i] < n && i - 1 - P[i] >= 0 &&
               T[i + 1 + P[i]] == T[i - 1 - P[i]]) {
            P[i]++;
        }
        if (i + P[i] > R) {
            C = i;
            R = i + P[i];
        }
    }
    return P;
}

string longestPalindrome(const string& s) {
    if (s.empty()) return "";
    vector<int> P = manacher(s);
    int max_len = 0;
    int center_index = 0;
    for (int i = 1; i < P.size()-1; i++) {
        if (P[i] > max_len) {
            max_len = P[i];
            center_index = i;
        }
    }
    int start = (center_index - max_len) / 2;
    return s.substr(start, max_len);
}

int main() {
    vector<string> test_cases = {
        "babad",
        "cbbd",
        "a",
        "ac",
        "abb",
        "abcba",
        "aaaa",
        ""
    };
    for (const string& s : test_cases) {
        cout << "Input: \"" << s << "\"" << endl;
        cout << "Longest palindrome: \"" << longestPalindrome(s) << "\"" << endl;
        cout << endl;
    }
    return 0;
}

13. 算法扩展

13.1 查找所有回文子串

通过遍历 \(P\) 数组，可以找到所有回文子串。

13.2 回文分割问题

可以用于优化回文分割的动态规划解法。

13.3 最长双回文子串

寻找两个不相交的回文子串，长度之和最大。

14. 与其他算法比较

14.1 与动态规划比较

动态规划需要 \(\mathcal{O}(n^2)\) 时间和空间，Manacher更优。

14.2 与后缀自动机比较

后缀自动机也可以解决但实现更复杂。

14.3 与哈希+二分比较

哈希方法通常需要 \(\mathcal{O}(n\log n)\) 且可能有哈希冲突。

15. 总结

Manacher算法以其优雅的设计和高效的性能成为解决最长回文子串问题的首选方法。通过巧妙地利用回文串的对称性质和预处理技巧，它将时间复杂度从 \(\mathcal{O}(n^2)\) 降低到 \(\mathcal{O}(n)\)，是算法设计中"以空间换时间"和"利用已知信息"的典范。