面试算法题精讲：最长回文子串

面试算法题精讲：最长回文子串

题目来源：5. 最长回文子串

题目描述：

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

如果字符串的反序与原始字符串相同，则该字符串称为回文字符串。

解法1：动态规划

对于一个子串而言，如果它是回文串，并且长度大于 2，那么将它首尾的两个字母去除之后，它仍然是个回文串。

根据这样的思路，我们就可以用动态规划的方法解决本题。

我们用 dp[i][j] 表示 s[i…j] 是否是回文串。

状态转移方程：dp[i][j] = dp[i+1][j-1] ∧ (s[i] == s[j])

动态规划中的边界条件：

1. dp[i][i] == true，对于长度为 1 的子串，它显然是个回文串。
2. dp[i][i+1] = (s[i] == s[i+1])，对于长度为 2 的子串，只要它的两个字母相同，它就是一个回文串。

根据这个思路，我们就可以完成动态规划了，最终的答案即为所有 dp[i][j]=true 中 j−i+1（即子串长度）的最大值。注意：在状态转移方程中，我们是从长度较短的字符串向长度较长的字符串进行转移的，因此一定要注意动态规划的循环顺序。

我们使用2层循环，外层枚举子串的长度 len，内层枚举子串起点 i，子串的终点 j = i + len - 1。之后进行转移转移即可。

代码：

class Solution
{
public:
    string longestPalindrome(string s)
    {
        // 特判
        if (s.size() < 2)
            return s;
        int n = s.size(), maxLen = 1, begin = 0;
        // 状态矩阵
        vector<vector<int>> dp(n, vector<int>(n, false));
        // dp[i][j] 表示 s[i...j] 是否是回文串
        // 初始化：所有长度为 1 的子串都是回文串
        for (int i = 0; i < n; i++)
            dp[i][i] = true;
        // 状态转移
        for (int len = 2; len <= n; len++) // 枚举子串长度
            for (int i = 0; i < n; i++)    // 枚举左边界
            {
                int j = i + len - 1; // 计算右边界
                if (j >= n)          // 右边界越界
                    break;
                if (s[i] != s[j])
                    dp[i][j] = false;
                else
                {
                    if (len <= 3)
                        dp[i][j] = true;
                    else
                        dp[i][j] = dp[i + 1][j - 1];
                }
                if (dp[i][j] == true && j - i + 1 > maxLen)
                {
                    maxLen = j - i + 1;
                    begin = i;
                }
            }
        return s.substr(begin, maxLen);
    }
};

结果：

复杂度分析：

时间复杂度：O(n²)，其中 n 是字符串 s 的长度。

空间复杂度：O(n²)，其中 n 是字符串 s 的长度。

解法2：中心拓展算法

「中心扩散法」的基本思想是：遍历每一个下标，以这个下标为中心，利用「回文串」中心对称的特点，往两边扩散，看最多能扩散多远。

从每一个位置出发，向两边扩散即可。遇到不是回文的时候结束。

每个位置向两边扩散都会出现一个窗口大小（len = right - left）。如果 len>maxLen（用来表示最长回文串的长度），则更新 maxLen 的值。

因为我们最后要返回的是具体子串，而不是长度。因此，还需要记录一下 maxLen 时的起始位置 start。

代码：

/*
 * @lc app=leetcode.cn id=5 lang=cpp
 *
 * [5] 最长回文子串
 */

// @lc code=start
class Solution
{
public:
    string longestPalindrome(string s)
    {
        int n = s.length();
        int start = 0, end = 0;

        auto expendAroundCenter = [&](int left, int right) -> pair<int, int>
        {
            while (left >= 0 && right < n && s[left] == s[right])
            {
                left--;
                right++;
            }
            return {left + 1, right - 1};
        };

        for (int i = 0; i < n; i++)
        {
            auto [left1, right1] = expendAroundCenter(i, i);
            if (right1 - left1 > end - start)
            {
                start = left1;
                end = right1;
            }
            auto [left2, right2] = expendAroundCenter(i, i + 1);
            if (right2 - left2 > end - start)
            {
                start = left2;
                end = right2;
            }
        }
        int len = end - start + 1;
        return s.substr(start, len);
    }
};
// @lc code=end

结果：

复杂度分析：

时间复杂度：O(n²)，其中 n 是字符串 s 的长度。

空间复杂度：O(1)。

解法3：Manacher 算法

算法详解：https://blog.csdn.net/dyx404514/article/details/42061017。

代码：

class Solution
{
private:
    string manacher(string s)
    {
        // 特判
        if (s.empty() || s.size() < 2)
            return s;
        // 对原始字符串 s 做处理，添加分隔符（例如：将 abc 变成 #a#b#c#）
        string str = addBoundaries(s, '#');
        int n = str.size();
        // right 表示已经探测到的字符串最右边的可达范围
        int right = 0;
        // center 表示根据最右边的可达范围的中心对称位置
        int center = 0;
        int start = 0, maxLen = 0;
        // p 数组记录所有已探测过的回文半径，后面我们再计算 i 时，根据 p[i_mirror] 计算 i
        vector<int> p(n, 0);
        // 从左到右遍历处理过的字符串，求每个字符的回文半径
        for (int i = 0; i < n; i++)
        {
            // 根据i和right的位置分为两种情况：
            // 1. i <= right，利用已知的信息来计算 i
            // 2. i > right，说明 i 的位置时未探测过的，只能用中心探测法
            if (right >= i)
            {
                // 这句是关键，不用再像中心探测那样，一点点的往左/右扩散，根据已知信息
                // 减少不必要的探测，必须选择两者中的较小者作为左右探测起点
                int minArmLen = min(right - i, p[2 * center - i]);
                p[i] = expand(str, i - minArmLen, i + minArmLen);
            }
            else // i 落在 right 右边，是没被探测过的，只能用中心探测法
                p[i] = expand(str, i, i);
            // 大于right，说明可以更新最右端范围了，同时更新 center
            if (i + p[i] > right)
            {
                center = i;
                right = i + p[i];
            }
            // 找到了一个更长的回文半径，更新原始字符串的 start 位置
            if (p[i] > maxLen)
            {
                maxLen = p[i];
                start = (i - p[i]) / 2;
            }
        }
        // 根据 start 和 maxLen ，从原始字符串中截取一段返回
        return s.substr(start, maxLen);
    }
    // 辅函数 - 以s [left...right] 为起点，计算回文半径（可拓展的步数）
    int expand(string s, int left, int right)
    {
        while (left >= 0 && right < s.size() && s[left] == s[right])
        {
            left--;
            right++;
        }
        // 由于while循环退出后left和right各多走了一步，所以在返回的总长度时要减去2
        return (right - left - 2) / 2;
    }
    // 辅函数 - 对原始字符串 s 进行预处理（添加分隔符）
    string addBoundaries(string s, char divide)
    {
        if (s.empty())
            return "";
        string t;
        for (char &c : s)
        {
            t += divide;
            t += c;
        }
        t += divide;
        return t;
    }

public:
    string longestPalindrome(string s)
    {
        return manacher(s);
    }
};

结果：

复杂度分析：

时间复杂度：O(n)，其中 n 是字符串 s 的长度。

空间复杂度：O(n)，其中 n 是字符串 s 的长度。