LeetCode 5 最长回文子串

题目描述

给定一个字符串 s，找到 s 中最长的回文子串。你可以假设 s 的最大长度为 1000。
例如：
给定字符串 “babad”
则最长回文子串为“bab” 或 “aba”

解析

这是一道经典问题，也有很经典的Manacher解法。
根据回文串的定义，我们能直接想到的方法就是找到中心，向两侧扩展，找到回文部分的边界即可。这样我们可以枚举每一个字符作为中心，向两侧扩展找到以该字符为中心的回文子串，并返回其中最长的即可。要注意的是，回文字符串长度是奇数和偶数时，判断方法并不完全一致，这样可以写出“中心扩展法”代码如下：

string longestPalindrome(string s) {
        int len=1,start=0;
        //奇数
        for(int i=0;i<s.size();++i){
            int k=1,tmp=1;
            while(i-k>=0&&i+k<s.size()&&s[i-k]==s[i+k]){
                tmp+=2;
                if(tmp>len){
                    len=tmp;
                    start=i-k;
                }
                ++k;
            }
            
        }
        //偶数
        for(int i=0;i<s.size();++i){
            int j=i,k=i+1,tmp=0;
            while(j>=0&&k<s.size()&&s[j]==s[k]){
                tmp+=2;
                if(tmp>len){
                    len=tmp;
                    start=j;
                }
                --j;
                ++k;
            }
        }
        return s.substr(start,len);
    }

这种方法我们需要分别讨论奇数和偶数的情况，上述的代码的两个for循环，就是分别处理这两种情况，对于奇数长度，是指以当前第i个字符为中心，逐个判断i-k和i+k位置是不是一致，是的话就继续扩展，同时如果长度达到更长，就更新长度和起点位置；对于偶数，则是从i和i+1是否一样开始，分别向左右扩展判断。
这种方法的时间复杂度是$O(N^2)$

Manacher方法

“马拉车”是这一问题$O(N)$的解法，思路非常巧妙。
首先为了应对奇数偶数的问题，算法对输入字符串做了扩展，将两个字符之间加入同一个特殊符号，比如’#’，同时在起始位置添加另一个特殊符号，比如’$’，避免越界。
这样做的好处是，将原字符串的所有子串都变成了奇数个，也就是一定以某个位置i为起点，左右延伸一定范围。对于奇数长度的子串，添加的‘#’是偶数个，而偶数长度的子串添加的‘#’是奇数个，所以总长度一定是奇数的。
也就是说，如果原字符串有一个奇数长度的回文子串，变换后也是以原有中心为中心扩展的，而偶数长度，则是以最中间两个字符之间添加的‘#’为中心扩展的。
比如：
aba -> $#a#b#a# 中心是b
cccc -> $#c#c#c#c# 中心是 #
经过上述步骤，原字符串的所有子串都可以看做是新字符串中的奇数长度子串。
算法需要一个数组，记为 rad , rad[i]表示以位置i字符为中心的回文子串的半径（左右延伸最长距离）。
同时记录当前能延伸到最右端的回文子串信息，分别用 id 和mx表示这个延伸到最右端的回文子串的中心，和最右位置，也即 $mx=id+rad[id]$
当我们遍历到位置i的字符串时，首先包含两种情况：
第一，i<mx， 也就是i位置仍然处于id为中心的回文串内部，那么i位置存在相对于id的对称点j，并且$j=id-(i-id)=2\ast id-i$
同理，mx也存在对称点p满足$p=2\ast id-mx$
以id为中心的回文串就其实是p到mx这一部分。
这时以i为中心的回文串半径是多少呢？我们需要关注已经计算过（从左向右计算）i的对称点j的情况。设j的回文串最左端是pj1，右端是pj2。
首先，如下图，如果pj1位置比mx的对称点p还要靠左， 说明从pj1到 j 的子串和 j 到 pj2 处是对称的。又因为 p 到 mx 也是以 id 为中心的回文串，那么 p 到 j 的部分和 i 到 mx 的部分也是对称的。

由于mx右边的部分还没有遍历到，并不知道是否仍能扩展子串，所以上述情况可以说明，p 到 j 这部分和 i 到 mx 这部分是中心对称。同时 j 到 pj2 这部分在 i 的左侧也存在对称部分，但是由于mx右侧没有检查过，只能确定 mx关于i的对称点 pi1 位置到mx部分一定是个回文串。
所以 以 i 为中心的回文串半径 （rad[i]）至少是 mx - i。

另一种情况，是 i 的对称点 j 的最左端并没有超过 p
那么显然以 j 为中心的回文串 pj1 到 pj2 全都在以id为中心的回文串内，右侧一定存在 以 i 为中心的回文子串 pi1 到 pi2，这部分全部包括在已知的回文串内，不存在截断情况，那么 以 i 为中心的回文串半径 （rad[i]）至少是 rad[j]。

第二如果 i>=mx, 那么以id为中心的回文子串信息我们就用不上了，没有了已知的对称关系，此时只能将 rad[i]记为1 ，再进行扩展判断。
综上，对于 i<mx，我们取 rad[j] 和 mx-i里的较小值（rad[j]更小说明i为中心扩展不到mx，以rad[j]为准；rad[j]更大则在i右侧超过了mx无法判断所以取mx-i），而对于i>=mx，则取1.
这就是马拉车算法非常经典的更新公式
rad[i]=mx>i?min(rad[2*id-i],mx-i):1;
这一步也是算法最难理解的，也是充分运用了已知回文串对称性的部分。
当然上述公式只是基于已知对称性给出了rad[i]的最小取值，右侧尚未遍历，完全可能出现更长的情况，所以需要进一步扩展判断，看能否进一步得到更大的rad[i]。
随后判断以 i 为中心的回文串的最右端是否超过了原有的mx，是的话就进一步更新id为 i ，而mx 更新为 i+rad[i]
同时，维护最长的半径和对应中心位置，每次遇到更长的半径，就更新这个值。这里要注意，这个半径和中心都是针对增加了特殊字符后的字符串，而非原始输入的字符串，在输出时要转化回去。
C++代码如下：

string longestPalindrome(string s) {
        string tmp="$#";
        for(auto c:s){
            tmp+=c;
            tmp+='#';
        }
        vector<int>rad(tmp.size(),0);
        int id=0,mx=0,resCenter=0,resLen=0;
        for(int i=1;i<tmp.size();++i){
            rad[i]=mx>i?min(rad[2*id-i],mx-i):1;
            while(tmp[i+rad[i]]==tmp[i-rad[i]]) ++rad[i];
            if(i+rad[i]>mx){
                id=i;
                mx=i+rad[i];
            }
            if(resLen<rad[i]){
                resLen=rad[i];
                resCenter=i;
            }
        }
        return s.substr((resCenter - resLen) / 2, resLen - 1);
    }

首先将原始字符串s增添特殊符号转化为这里的tmp字符串，然后遍历所有位置，先计算rad[i]的最小取值，再尝试能否进一步延伸，然后维护最右端回文串信息 id， mx和全局最长回文子串信息 resCenter和resLen。