5. 最长回文子串

解法一：动态规划

回文串问题天生具有子问题性质：

一个回文串去掉两头以后，剩下依然是回文串。

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

根据这样的思路，我们就可以用动态规划的方法解决本题。我们用\(P(i,j)\)表示字符串 \(s\) 的第 \(i\) 到 \(j\) 个字母组成的串（下文表示成 \(s[i:j]\)）是否为回文串：

\[P(i,j) = \begin{cases} \text{true,} &\quad\text{如果子串} s_i \dots s_j \text{是回文串}\\ \text{false,} &\quad\text{其它情况} \end{cases} \]

这里的「其它情况」包含两种可能性：

• \(s[i, j]\) 本身不是一个回文串；
• \(i>j\)，此时 \(s[i, j]\) 本身不合法。

那么我们就可以写出动态规划的状态转移方程：

\[P(i, j) = P(i+1, j-1) \wedge (S_i == S_j) \]

也就是说，只有 \(s[i+1:j-1]\) 是回文串，并且 \(s\) 的第 \(i\) 和 \(j\) 个字母相同时，\(s[i:j]\) 才会是回文串。

上文的所有讨论是建立在子串长度大于 \(2\) 的前提之上的，我们还需要考虑动态规划中的边界条件，即子串的长度为 \(1\) 或 \(2\)。对于长度为 \(1\) 的子串，它显然是个回文串；对于长度为 \(2\) 的子串，只要它的两个字母相同，它就是一个回文串。因此我们就可以写出动态规划的边界条件：

\[\begin{cases} P(i, i) = \text{true} \\ P(i, i+1) = ( S_i == S_{i+1} ) \end{cases} \]

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

class Solution {
public:
    string longestPalindrome(string s) {
        int n = s.size();
        s = ' ' + s;
        vector<vector<bool>> f(n + 1, vector<bool>(n + 1));
        int ans = 0, l = 0;
        for(int i = n; i; i--)
            for(int j = i; j <= n; j++)
            {
                if(i == j) f[i][j] = true;
                else if(i + 1 == j) f[i][j] = (s[i] == s[j]);
                else f[i][j] = f[i + 1][j - 1] && (s[i] == s[j]);

                if(f[i][j] && ans < j - i + 1)
                {
                    ans = j - i + 1;
                    l = i;
                }
            }

        return s.substr(l, ans);
    }
};

解法二：中心扩展

我们枚举所有的「回文中心」并尝试「扩展」，直到无法扩展为止，此时的回文串长度即为此「回文中心」下的最长回文串长度。我们对所有的长度求出最大值，即可得到最终的答案。

class Solution {
public:
    pair<int, int> check(string& s, int l, int r) {
        while(l >= 0 && r < s.size() && s[l] == s[r]) 
            l--, r++;
        return {l + 1, r - 1};
    }
    string longestPalindrome(string s) {
        int ans = 0, l = 0;
        for(int i = 0; i < s.size(); i++)
        {
            auto [l1, r1] = check(s, i, i + 1);
            if(ans < r1 - l1 + 1) 
            {
                ans = r1 - l1 + 1;
                l = l1;
            }
            auto [l2, r2] = check(s, i, i);
            if(ans < r2 - l2 + 1) 
            {
                ans = r2 - l2 + 1;
                l = l2;
            }
        }
        return s.substr(l, ans);
    }
};