解法一：动态规划
回文串问题天生具有子问题性质：
一个回文串去掉两头以后，剩下依然是回文串。
对于一个子串而言，如果它是回文串，并且长度大于 (2)，那么将它首尾的两个字母去除之后，它仍然是个回文串。
根据这样的思路，我们就可以用动态规划的方法解决本题。我们用(P(i,j))表示字符串 (s) 的第 (i) 到 (j) 个字母组成的串（下文表示成 (s[i:j])）是否为回文串：
[P(i,j) = egin{cases} ext{true,} &quad ext{如果子串} s_i dots s_j ext{是回文串}\ ext{false,} &quad ext{其它情况} 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) 的子串，只要它的两个字母相同，它就是一个回文串。因此我们就可以写出动态规划的边界条件：
[egin{cases} P(i, i) = ext{true} \ P(i, i+1) = ( S_i == S_{i+1} ) end{cases}
]
根据这个思路，我们就可以完成动态规划了，最终的答案即为所有 (P(i, j) = ext{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);
}
};