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

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

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

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]=truedp[j+1][i1]s[j]==s[i] && dp[j+1][i1]j=i0<ij2ij>2(1)(2)(3) d p [ j ] [ i ] = { (1) t r u e j = i (2) d p [ j + 1 ] [ i − 1 ] 0 < i − j ≤ 2 (3) s [ j ] == s [ i ]  &&  d p [ j + 1 ] [ i − 1 ] i − j > 2

代码如下

/** * @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('')
}

《【 Javascript刷LeetCode系列】5. Longest Palindromic Substring 最长回文子串问题》
可以看到排名非常不错,这个算法的速度确实可以。

点赞

发表评论

电子邮件地址不会被公开。 必填项已用*标注