Manacher算法

 

参考资料：

　　[1]:左神进阶班 [ 提取码：3knt ]

 

自学笔记：

　　1.何为Manacher算法（摘自百度百科）？

　　　　Manachar算法主要是处理字符串中关于回文串的问题的；

　　　　它可以在O(n)的时间处理出以字符串中每一个字符为中心的回文串半径；

　　2.相关概念介绍

　　　　(1):何为回文半径？

　　　　　　例如：

　　　　　　0　　1　　2　　3　　4

　　　　　　a　　b　　c　　b　　a

　　　　　　以0处的a为中心的最长回文子串为 a ，其回文半径长度为 1(a)；

　　　　　　以1处的b为中心的最长回文子串为 b ，其回文半径长度为 1(b)；

　　　　　　以2处的c为中心的最长回文子串为 abcba ，其回文半径长度为 3(cba)；

　　　　　　以3处的b为中心的最长回文子串为 b ，其回文半径长度为 1(b)；

　　　　　　以1处的a为中心的最长回文子串为 a ，其回文半径长度为 1(a)；

　　　　(2):何为回文半径数组？

　　　　　　定义radius[]为回文数组，那么 radius[ i ] 指的是以第 i 个字符为中心的回文半径长度。

　　　　(3):何为最右回文边界？

　　　　　　还是以上一个例子为例：

　　　　　　以0处的a为中心的最右回文边界为 0；

　　　　　　以1处的b为中心的最右回文边界为 1（超过了0-'a'字符所达到的最右端，更新最右回问边界）；

　　　　　　以2处的c为中心的最右回文边界为 4（超过了1-'b'字符所达到的最右端，更新最右回问边界）；

　　　　　　以3处的b为中心的最右回文边界为 4（未超过2-'c'字符所达到的最右端，不更新最右回文边界）；

　　　　　　以4处的a为中心的最右回文边界为 4（未超过2-'c'字符所达到的最右端，不更新最右回文边界）；

　　3.Manacher算法介绍

　　　　介绍完了基本概念后，开始回归正题；

　　　　定义字符数组 s[] 为所要求的字符串；

　　　　①首先，需要将 s[] 预处理，在开始位置和结尾位置，以及字符间加上字符 ‘#’

　　　　例如，假设 s[] = "abcba";

　　　　那么，预处理后，字符串变为 s[]="#a#b#c#b#a#";

　　　　②假设radius[0,......i-1]已求出，达到的最右回文边界为R，第一个达到最右回文边界的下标为 k

　　　　那么，如何高效的求解dp[ i ]呢？

　　　　1)如果 i ≥ R ，暴力扩

　　　　　　比对 (i+1,i-1) , (i+2,i-2) , .........  直到求出不相等位置或越界，求解出radius[ i ]；

　　　　　　（ (i+1,i-1) : 判断 s[ i+1 ] 是否等于 s[ i-1 ] ）

　　　　2)如果 i < R

　　　　　　求出 i 关于 k 的对称点 j = k-(i-k)

　　　　　　[1]:如果 i+radius[ j ]-1 < R , 那么 radius[ i ]=radius[ j ];

　　　　　　[2]:如果 i+radius[ j ]-1 > R , 那么 radius[ i ]=R-i+1;

　　　　　　[3]:如果 i+radius[ j ]-1 = R , 定义 tot = radius[ j ] , 判断 (i+tot,i-tot) , (i+tot+1,i-tot-1) , ....... 直到求出不相等位置或越界，求解出radius[ i ]；

　　　　证明详见参考资料；

模板：

struct Manacher
{
    char s[maxn<<1];
    int r[maxn<<1];

    void Init(char *ss,int len)
    {
        int index=0;
        s[index++]='#';
        for(int i=0;i < len;++i)
        {
            s[index++]=ss[i];
            s[index++]='#';
        }
        ///加上保险，防止多组输入遗留上次的信息，因为我习惯于用strlen(s)求长度
        s[index]='\0';
    }
    void manacher()
    {
        int R=-1;///最右回文边界
        int K;///最右会问边界对应的中心下标
        int len=strlen(s);
        for(int i=0;i < len;++i)
        {
            int cnt=0;
            if(i >= R)///情况(1)暴力扩
            {
                for(;i+cnt < len && i-cnt >= 0 && s[i+cnt] == s[i-cnt];cnt++);
                r[i]=cnt;
            }
            else///情况(2)的三种小情况，[1],[2]可合并为 != R
            {
                int j=2*K-i;///i关于k的对称点
                if(i+r[j]-1 != R)///不压边界
                    r[i]=min(r[j],R-i+1);///取最小值
                else///压线才往两边暴力扩
                {
                    cnt=R-i;
                    for(;i+cnt < len && i-cnt >= 0 && s[i+cnt] == s[i-cnt];cnt++);
                    r[i]=cnt;
                }
            }
            if(i+cnt-1 > R)///判断是否更新R,K
            {
                R=i+cnt-1;
                K=i;
            }
        }
    }
}_mana;

之前年轻不懂事，原来 manacher 代码还可以更精简QWQ；

精简代码：

/**
    Manacher算法在O(n)的时间复杂度下求解串s的回文半径
*/
struct Manacher
{
    char s[maxn<<1];///注意数组大小，根据题意而定
    int r[maxn<<1];///最右回文半径数组

    ///传入待求解字符串ss，注意ss下标要从0开始，len是ss的长度
    void Init(char *ss,int len)
    {
        int index=0;
        s[index++]='#';
        for(int i=0;i < len;++i)
        {
            s[index++]=ss[i];
            s[index++]='#';
        }
        s[index]='\0';///最好加上，防止多组输入时遗留上一次的信息
    }
    void manacher()
    {
        int len=strlen(s);
        int R=-1;///最右回文边界，正好压住边界
        int C;///最右回文边界对应的中点下标
        for(int i=0;i < len;++i)
        {
            r[i]=R > i ? min(R-i+1,r[2*C-i]):1;
            for(;i-r[i] >= 0 && i+r[i] < len && s[i-r[i]] == s[i+r[i]];r[i]++);
            if(i+r[i]-1 > R)///i处的右回文区间[i,i+r[i]-1]
            {
                R=i+r[i]-1;///R正好压住，所以r[i]赋初值时是R-i+1而不是R-i
                C=i;
            }
        }
    }
}_mana;