JS最长回文子串

1,124 阅读1分钟

Offer 驾到,掘友接招!我正在参与2022春招打卡活动,点击查看活动详情

题目

给你一个字符串s,找到s中最长的回文子串。

  • 示例1:
输入:s = "babad"
输出:"bab"
解释:"aba" 同样是符合题意的答案。
  • 示例2:
输入:s = "cbbd"
输出:"bb"
  • 示例3:
输入:s = "a"
输出:"a"
  • 示例4:
输入:s = "ac"
输出:"a"

提示:

1 <= s.length <= 1000
s 仅由数字和英文字母(大写和/或小写)组成

解法

暴力枚举法

思路

暴力枚举法虽然时间复杂度高,但是思路清晰、写法简单、正确性高,完全可以使用暴力匹配算法检验我们编写的算法的正确性。

代码

var longestPalindrome_bf = function(s) {
    if (!s) return '';
    var longest = s[0], str, i, j, len;
    var isPalindrom = function (left, right) {
        while (left < right && s[left] === s[right]) {
            left++;
            right--;
        }
        return left >= right;
    }
    for (len = 2; len <= s.length; len++) {
        for (i = 0; i < s.length; i++) {
            j = i + len - 1;
            if (isPalindrom(i, j)) {
                str = s.slice(i, j + 1);
                if (longest.length < str.length) longest = str;
            }
        }
    }
    return longest;
}
  • 时间复杂度O(n^3)
  • 空间复杂度O(1)

中心扩散法

思路

暴力枚举法时间复杂度高,除此之外,还容易想到的是枚举可能出现的回文子串的中心位置,从中心位置尽可能扩散出去,得到一个回文串。

遍历原字符串,每个字符或每两个字符中间,都可能被当成回文子串的中心,利用回文串的中心对称的特点,尽量往两边扩散,获取最大的扩散面积。

因此,中心扩散法的思路是:遍历每一个索引,以这个索引为中心,利用回文串中心对称的特点,往两边扩散,看最多能扩散多远。

枚举“中心位置”时间复杂度为 O(n) ,从“中心位置”扩散得到“回文子串”的时间复杂度为 O(n) ,因此时间复杂度可以降到 O(n^2)。

在这里要注意一个细节:回文串在长度为奇数和偶数的时候,回文中心的形式是不一样的。

  • 奇数回文串的中心是一个具体的字符,例如:回文串“aba”的中心字符是“b”;
  • 偶数回文串的中心是位于中间两个字符的空隙,例如:回文串“abba”的中心是两个“b”中间的空隙。

代码

var longestPalindrome = function (s) {
    if (!s) return '';
    if (s.length === 1) return s;
    if (s.length === 2) return s[0] === s[1] ? s : s[1];
    let maxStr = '',
    len = s.length;
    for (let i = 0; i < len; i++) {
        let even = '', // 定义偶数中心回文
        odd = ''; // 定义奇数中心回文
        if (s[i] === s[i + 1]) {
            // 若是偶数中心回文
            let evenIndex = center(s, i - 1, i + 2); // 比较中心的前一项和后一项
            even = s.slice(evenIndex.left, evenIndex.right)
        }
        let oddIndex = center(s, i - 1, i + 1); // 奇数中心回文
        odd = s.slice(oddIndex.left, oddIndex.right);
        let longer = even.length > odd.length ? even : odd; // 比较奇、偶
        maxStr = maxStr.length > longer.length ? maxStr : longer
    }
    return maxStr
}
// 中心扩展
function center(s, left, right) {
    let len = s.length;
    while (left >= 0 && right < len && s[left] === s[right]) {
        left--;
        right++;
    }
    return {
        left: left + 1,
        right: right
    }
}

动态规划1

思路

DP可能是解这个问题的一个好方法,然而算法复杂度依然是 O(N^2) 的,而且空间复杂度也是 O(N^2)。

我们假设用 P[i][j] 来表示 s[i..j] 是否是一个回文子串。

它的计算公式长这样:

P[i][j] = s[i] === s[j] && P[i + 1][j - 1] ? true : false;

代码

var longestPalindrome_dp = function(s) {
    var i, j, len;
    var isPalindrom = new Array(s.length);
    for (i = 0; i < s.length; i++) {
        isPalindrom[i] = new Array(s.length).fill(false);
    }
    var maxLen = 1, longestBegin = 0;
    for (i = 0; i < s.length; i++) {
        isPalindrom[i][i] = true;
        if (i < s.length - 1 && s[i] === s[i + 1]) {
            isPalindrom[i][i + 1] = true;
            maxLen = 2;
            longestBegin = i;
        }
    }
    for (len = 3; len <= s.length; len++) {
        for (i = 0; i < s.length; i++) {
            j = len + i - 1;
            if (s[i] === s[j] && isPalindrom[i + 1][j - 1]) {
                isPalindrom[i][j] = true;
                maxLen = len;
                longestBegin = i;
            }
        }
    }
    return s.slice(longestBegin, longestBegin + maxLen);
}

动态规划2

思路

DP的空间复杂度是O(N^2),主要用来保存二维数组 P[i][j],而且只用了一半。

我们可以把空间复杂度降到O(1),只存找到的最长回文串即可。枚举轴心位置,并进行扩展。如果是回文,则轴心两边的字符应该对称相等。

需要考虑到长度奇偶情况的不同,如果是奇数长度,轴心就是一个字符;如果是偶数长度,轴心则不在字符串中。

代码

var longestPalindrome_enum = function(s) {
    if (!s) return '';
    var longest = s[0];
    var expandAroundCenter = function (left, right) {
        while (left >= 0 && right < s.length && s[left] === s[right]) {
            left--;
            right++;
        }
        return s.slice(left + 1, right);
    }
    for (var i = 0; i < s.length; i++) {
        // 奇数
        var odd = expandAroundCenter(i, i);
        if (odd.length > longest.length) longest = odd;
        // 偶数
        var even = expandAroundCenter(i, i + 1);
        if (longest.length < even.length) longest = even;
    }
    return longest;
}

Manacher算法

思路

相比降低空间复杂度,降低时间复杂度要难得多。这里有一个O(N)时间复杂度的算法,叫做 Manacher 算法。

能够从O(N^2)降到O(N),这个算法很巧妙。它首先解决了长度奇偶不同的问题。

通过向字符串中加入一些特殊字符来使长度均为奇数。特殊字符即为原字符串的字符集中没有的字符。如 'aba' 中插入'#',变成'#a#b#a#'。

然后提出了一个回文半径(P)的概念:

T = # a # b # a # a # b # a #
P = 0 1 0 3 0 1 6 1 0 3 0 1 0

它代表了以该字符为轴心的回文串对折后的长度。由于插入了特殊字符,如果最长回文字符串的长度为偶数,则轴心会出现在"#"上。

容易看出上面的例子中,最大回文子串的轴心就是P为6的字符。最大回文子串为'abaaba',长度刚好为6。

这显然不是巧合,接下来就是要计算P,记下其最大值及对应下标,即可。目标时间复杂度 O(N)。当然,这个算法最难的部分,就是计算P。

正常计算P的话,时间复杂度依然是O(N^2),但是如果利用回文串的对称特性,减少搜索,就可以将复杂度降至 O(N)。

计算 P 就是以每一个字符为轴心计算回文半径,也就是从每一个字符开始向两边搜索,那么右边必然会搜索到尚未遍历到的字符,如果我们记下最大能搜索到的右边界 R 。在后面的遍历搜索中,如果当前 T[i] 在边界内,即比最大右边界小,那么也就是在一个已搜索的回文子串中,假设 i' 是 i 对应当前最大 R 的轴心 C 的对称位置(即T[i] == T[i']),可以做出下面的结论:

if P[i'] < R-i
then P[i] = P[i']
else P[i] >= P[i'] (需要进一步扩展搜索得出)

另一种情况,如果当前字符T[i]不在边界内,即我们不能得出任何结论,所以P[i] = 0

代码

var longestPalindrome_manacher = function(s) { 
    s = '^#' + s.split('').join('#') + '#$'; 
    var radius = new Array(s.length).fill(0); 
    var C = 0, centerIndex = 0, maxRight = 0, maxLen = 0; 
    for (var i = 1; i < s.length - 1; i++) { 
    // 计算初始回文半径, i' = 2 * C - i 
    radius[i] = (maxRight > i) ? Math.min(maxRight - i, radius[2 * C - i]) : 0; 
    // 扩展半径 
    while (s[i + 1 + radius[i]] && s[i - 1 - radius[i]] && s[i + 1 + radius[i]] === s[i radius[i]]) radius[i]++; 
    // 更新当前搜索的最大右边界和位置 
    if (i + radius[i] > maxRight) { 
        C = i; maxRight = i + radius[i]; 
    } 
    // 更新最大回文串长度及位置 
    if (maxLen < radius[i]) { 
        maxLen = radius[i]; 
        centerIndex = i; 
    } 
} 
return s.slice((centerIndex - maxLen), (centerIndex + maxLen + 1)).split('#').join(''); };