什么是马拉车算法(Manacher's Algorithm)?

提出问题

最长回文子串问题:给定一个字符串,求它的最长回文子串长度。

如果一个字符串正着读和反着读是一样的,那它就是回文串。如a、aa、aba、abba等。

暴力解法

简单粗暴:找到字符串的所有子串,遍历每一个子串以验证它们是否为回文串。一个子串由子串的起点和终点确定,对于一个长度为n的字符串,共有n^2个子串。这些子串的平均长度大约是n/2,因此这个解法的时间复杂度是 \(O(n^3)\)。明显不可取。

方法改进

回文子串是连续的,而且是对称的。长度为奇数回文串以最中间字符的位置为对称轴左右对称,而长度为偶数的回文串的对称轴在中间两个字符之间的空隙。可否利用这种对称性来提高算法效率呢?答案是肯定的。我们知道整个字符串中的所有字符,以及字符间的空隙,都可能是某个回文子串的对称轴位置。可以遍历这些位置,在每个位置上同时向左和向右扩展,直到左右两边的字符不同,或者达到边界。对于一个长度为n的字符串,这样的位置一共有 n+n-1=2n-1 个,在每个位置上平均大约要进行 n/4 次字符比较,于是此算法的时间复杂度是 \(O(n^2)\)

另外一种改进方法是利用动态规划,DP[i][j]定义成子串[i, j]是否是回文串。外循环 i从 n−1 往 0 遍历,内循环 j 从 i 往 n−1 遍历,若s[i]==s[j]:

  • 若i==j,则dp[i][j]=true;
  • 若i和j是相邻的,则dp[i][j]=true;
  • 若i和j中间只有一个字符,则dp[i][j]=true;
  • 否则,检查dp[i+1][j-1]是否为true,若为true,那么dp[i][j]就是true。

前三条可以合并,即 j−i≤2。求得dp[i][j]真值后,也可快速解决问题。时间复杂度:\(O(n^2)\)

Manacher's Algorithm

对于 \(O(n^2)\) 的复杂度,或许还不满足,是否可以再优化一些呢?

先分析改进方法中的缺陷,利用回文中心需要分奇偶两种情况讨论,两种改进都会重复访问子串,降低效率。

Manacher's Algorithm正是针对这两个问题进行进一步的改进,将时间复杂度降到了神奇的 \(O(n)\)

问题一:回文长度奇偶性问题

为了不区分奇偶两种情况,对字符串作预处理,在所有字符之间(包括首尾)插入相同字符如'#',处理之后所有的子串都是奇数长度的。如aba→#a#b#a#。

插入的是同样的符号,且符号不存在于原串,因此子串的回文性不受影响,原来是回文的串,插完之后还是回文的,原来不是回文的,依然不会是回文。

问题二:重复访问问题

定义回文半径:回文串中最左或最右位置的字符与其对称轴的距离。算法中定义回文半径数组 \(RL\)\(RL[i]\) 表示以第i个字符为对称轴的回文串的回文半径。

定义 \(MaxRight\),表示当前访问到的所有回文子串,所能触及的最右一个字符的位置。另外还要记录下 \(MaxRight\) 对应的回文串的对称轴所在的位置,记为 \(pos\)

核心代码:RL[i] = i < MaxRight ? min(RL[2*pos-i], MaxRight-i) : 1;

理解了这行代码,可以说就理解了这个算法。我们来分情况讨论:

(1)i < MaxRight时,可以再分两种情况:

①MaxRight - i > RL[2*pos-i],如下图,以S[j]为中心的回文子串包含在以S[id]为中心的回文子串中,由于 i 和 j 对称,以S[i]为中心的回文子串必然包含在以S[id]为中心的回文子串中,所以必有 P[i] = P[j]。

②MaxRight - i < RL[2*pos-i],如下图,以S[j]为中心的回文子串不一定完全包含于以S[id]为中心的回文子串中,但是基于对称性可知,下图中两个绿框所包围的部分是相同的,也就是说以S[i]为中心的回文子串,其向右至少会扩张到mx的位置,也就是说 P[i] >= mx - i。

(2)i > MaxRight时,无法对 P[i]做更多的假设,只能P[i] = 1,然后再去慢慢匹配了。

代码实现

返回最长的回文子串。代码中resLen为处理后字符串的最大回文半径,对应到原来的字符串中时,只需-1即是整个回文串的长度。

string Manacher(string s) {
    //预处理
    string t = "#";
    for (int i = 0; i < s.size(); ++i) {
        t += s[i];
        t += "#";
    }

    vector<int> RL(t.size(), 0);
    int MaxRight = 0, pos = 0;
    int resLen = 0, resCenter = 0;
    for (int i = 0; i < t.size(); ++i) {
        RL[i] = MaxRight > i ? min(RL[2 * pos - i], MaxRight - i) : 1;

        while (i-RL[i] >=0 && i+RL[i] < t.size() && t[i + RL[i]] == t[i - RL[i]])//扩展,注意边界
            ++RL[i];
        //更新最右端及其中心
        if (MaxRight < i + RL[i] -1) {
            MaxRight = i + RL[i] -1;
            pos = i;
        }
        if (resLen < RL[i]) {
            resLen = RL[i];
            resCenter = i;
        }
    }
    return s.substr((resCenter - resLen + 1) / 2 , resLen - 1);
}

时间复杂度:\(O(n)\)。在参考链接中有比较详细的证明过程。

参考链接:https://segmentfault.com/a/1190000003914228

参考链接:http://www.cnblogs.com/grandyang/p/4475985.html

posted @ 2018-03-08 15:16  AlvinZH  阅读(1967)  评论(0编辑  收藏  举报