力扣-5-最长回文字串
很明显是动态规划
这类字符串的动规问题一般是定义一个一维dp数组，dp[i]表示：前i个字符中XXX的长度
这里是否适用呢？
假设dp[i]表示前i个字符（包括i）中最长回文字符串的长度，能找到状态转移方程吗？
感觉有点麻烦，关键是这个回文的判断与递增长度的关系
看一眼题解
这里的动态规划没有直接着眼于最长回文子串长度的状态转移
而是对于回文串判断的状态转移：如果字符[i,j]是一个回文串，那么字符[i+1,j-1]是回文串，且字符i==j
但是这个怎么…或许不是像最上面那样，而是去扫描每个字符，但后按照上面的状态转移方程判断最长（向两边拓宽），同时动态更新最长长度，或许还能做一点剪枝
试着写写吧
string longestPalindrome(string s) {
// 如何保存最长的结果并返回呢？
int maxLen = 1,startIndex;
// 排除单字符，s[0]肯定不是个回文串，同理s[s.size()-1]也不会是
for (int i = 1; i < s.size() - 1; i++) {
int j = i - 1, k = i + 1;
while (j >= 0 && k <= s.size()) {
if (s[j] == s[k]) {
maxLen = max(maxLen, k - j + 1);
startIndex = j;
j--;
k++;
}
else break;
}
}
string str;
for (int i = startIndex; i < startIndex + maxLen; i++) str += s[i];
return str;
}
这是我写出的第一版代码，但是有个致命问题，就是没考虑到aabb这种双数的情况
因为像aa这种情况只会出现在第一次初始化的情况
string longestPalindrome(string s) {
// 如何保存最长的结果并返回呢？
int maxLen = 1,startIndex;
// 排除单字符，s[0]肯定不是个回文串，同理s[s.size()-1]也不会是
// 这么写，如果有存在长度一样的回文子串，后面的会覆盖前面的结果
// 这里没考虑到aabb这样双数的情况
for (int i = 1; i < s.size() - 1; i++) {
// 因为上面的范围设定，所以出事的j，k一定是合法的
int j = i - 1, k = i + 1;
if (s[j] != s[k]) {
if (s[j] == s[i]) k = i;
else if (s[i] == s[k]) j = i;
}
while (j >= 0 && k <= s.size()) {
if (s[j] == s[k]) {
maxLen = max(maxLen, k - j + 1);
startIndex = j;
j--;
k++;
}else break;
}
}
string str;
for (int i = startIndex; i < startIndex + maxLen; i++) str += s[i];
return str;
}
这是第二版的代码，我以为我解决了aabb的问题，但是没考虑好初始化，比如a
`for (int i = 1; i < s.size() - 1; i++)`这里for循环的写法要求长度至少为3
那么就要额外考虑长度为1，和2的情况
```C++
string longestPalindrome(string s) {
if (s.size() == 1) return s;
else if (s.size() == 2) {
if (s[0] == s[1]) return s;
else {
string s(1, s[0]);
return s;
}
}
// 如何保存最长的结果并返回呢？
int maxLen = 1,startIndex;
// 排除单字符，s[0]肯定不是个回文串，同理s[s.size()-1]也不会是
// 这么写，如果有存在长度一样的回文子串，后面的会覆盖前面的结果
// 这里没考虑到aabb这样双数的情况
for (int i = 1; i < s.size() - 1; i++) {
// 因为上面的范围设定，所以出事的j，k一定是合法的
// 但要是这么写，长度至少为3
int j = i - 1, k = i + 1;
if (s[j] != s[k]) {
if (s[j] == s[i]) k = i;
else if (s[i] == s[k]) j = i;
}
while (j >= 0 && k <= s.size()) {
if (s[j] == s[k]) {
maxLen = max(maxLen, k - j + 1);
startIndex = j;
j--;
k++;
}else break;
}
}
string str;
for (int i = startIndex; i < startIndex + maxLen; i++) str += s[i];
return str;
}
很不优雅地补了一段，还是不对，aaaa的情况不对
思路乱了，要考虑核长度1和核长度2向两边拓展的情况
中心拓展法
再瞄一眼题解
其实到目前已经不是动态规划了，而是中心拓展，另外就是这里考虑到中心长度有1和2两种情况，所以要单独抽出一个向两边拓展的函数
pair<int, int> expand(string s, int i, int j) {
while(i>=0&&j<s.size()&&s[i]==s[j]){
--i;
++j;
}
return { i+1,j-1 };
}
string longestPalindrome(string s) {
int start = 0, end = 0;
for (int i = 0; i < s.size(); ++i) {
pair<int,int> p1 = expand(s, i, i);
pair<int, int> p2 = expand(s, i, i + 1);// 这里返回值成长度可能为负
if (p1.second - p1.first > end - start) {
start = p1.first;
end = p1.second;
}
if (p2.second - p2.first > end - start) {
start = p2.first;
end = p2.second;
}
}
return s.substr(start, end - start + 1);
}
动态规划
还是要用动态规划做一遍
马拉车算法
参考：
