【 Javascript刷LeetCode系列】5. Longest Palindromic Substring 最长回文子串问题

回文子串是一个字符串中正反读完全一样的子串，如”aca”或”abba”，本题要求找出字符串中最长的回文子串，如下：

1.暴力解法

首先，暴力解法是最容易想到的办法，获取所有的子串，判断每一个子串是不是回文子串，然后找到最长的那个，一个字符串的子串数目有N(N+1)/2+1个，求出所有子串的时间复杂度为O(N²)，判断每个子串是否为回文子串的时间复杂度为O(N)，所以整个算法的时间复杂度为O(N³)。
代码如下：

/**
 * @param {string} s
 * @return {string}
 */
var longestPalindrome = function(s) {
    if (s.split('').reverse() === s.split('')) {
        return s;
    }
    let maxlength = 1,
        result = s[0],
        start = 0,
        end = 1,
        arr = [];
    for (let i = 0; i < s.length; i++) {
        arr.push([])
    }
    for (let i = 0; i < s.length; i++) {
        for (let j = 0; j < i; j++) {
            if (s[i] === s[j]) {
                arr[i][j] = 1;
            }
        }

    }

    return result;
};

时间复杂度为O(N³)速度可想而知，果不其然最后提交提示超时，那这得放弃这种算法了（本来也没指望暴力解法被accepted）。

2.动态规划

首先建立一个二维数组dp，dp[j][i]==true表示子串s[j][i]为回文字符串。另外如果s[j][i]是回文子串，那么s[j+1][i-1]也是回文子串，这样的话我们可以得到状态转移方程（这里吐槽一下，csdn的编辑器bug太多，写数学公式费了好大劲）：

$$dp[j][i] = \left\{ \begin{align} & true &&\text{$j=i$}\\ &dp[j+1][i-1] && \text{$0 < i -j \le 2 $} \\ & s[j]==s[i] \text{ && } dp[j+1][i-1]&& \text{$i-j>2$} \end{align} \right.$$
代码如下

/**
 * @param {string} s
 * @return {string}
 */
var longestPalindrome = function(s) {

    let maxlen = 1,
        result = s[0],
        start = 0,
        dp = [];
    for (let i = 0; i < s.length; i++) {
        dp.push([])
    }
    for (let i = 0; i < s.length; i++) {
        for (let j = 0; j < i; j++) {
            if (s[i] === s[j]) {
                if(i - j <= 2) {
                    if(i - j +1 > maxlen) {
                    start = j;
                    maxlen = i - j + 1;
                    }
                    dp[j][i] = true;
                }
                else if(dp[j+1][i-1]) {
                    if(i - j + 1 > maxlen) {
                        start = j;
                        maxlen = i - j + 1;
                    }
                    dp[j][i] = true;
                }
            }
        }

    }
    return s.substr(start,maxlen);
};

根据代码，不难得到动态规划的时间复杂度为O(N²)，然而很不幸，测试的结果仍然是超时，看来还需要时间复杂度更小的算法。

3. Manacher 算法

这种算法（谐音马拉车算法）非常神奇，将时间复杂度减小到了O(N)，具体的算法我就不细说了，因为我也是参考的别人的文章，推荐曾会玩的segmentfault专栏文章，感觉简单易懂，这里就直接贴出我的代码：

/**
 * @param {string} s
 * @return {string}
 */
var longestPalindrome = function(s) {

    s = '#' + s.split('').join('#') + '#';
    let maxRight = 0,
        pos = 0,
        RL = new Array(s.length),
        center = 0,
        maxR = 1;
    for (let i = 0; i < s.length; i++) {
        if (i < maxRight) {
            RL[i] = Math.min(RL[2*pos-i],maxRight-i);
        }
        else {
            RL[i] = 1;
        }
        while(i + RL[i] < s.length && i - RL[i] >= 0 && s[i+RL[i]] === s[i-RL[i]]) {
            RL[i] += 1;
        }
        if (RL[i] + i - 1 > maxRight) {
            maxRight = RL[i] + i - 1;
            pos = i;
        }
        if (RL[i] > maxR) {
            center = i;
            maxR = RL[i];
        }
    }
    return s.slice(center-maxR+1,center+maxR).split('#').join('')
}

可以看到排名非常不错，这个算法的速度确实可以。