数据结构与算法随笔之------最长回文子串四种方法求解（暴力枚举+动态规划+中心扩展+manacher算法（马拉车））
所谓回文串，就是正着读和倒着读结果都一样的回文字符串。
比如：
a, aba, abccba都是回文串，
ab, abb, abca都不是回文串。
一、暴力法
方法一：直接暴力枚举
求每一个子串时间复杂度O(N^2), 判断子串是不是回文O(N)，两者是相乘关系，所以时间复杂度为O(N^3)。
#include
using namespace std;
string longestPalindrome(string &s)
{
int len = s.size(); //字符串长度
int maxlen = 1; //最长回文字符串长度
int start = 0; //最长回文字符串起始地址
for(int i = 0; i < len; i++) //起始地址
{
for(int j = i + 1; j < len; j++) //结束地址
{
int tmp1 = i, tmp2 = j;
while(tmp1 < tmp2 && s.at(tmp1) == s.at(tmp2))//判断是不是回文
{
tmp1++;
tmp2--;
}
if(tmp1 >= tmp2 && j - i + 1 > maxlen)
{
maxlen = j - i + 1;
start = i;
}
}
}
return s.substr(start, maxlen);
}
int main()
{
string s;
cout << "Input source string: ";
cin >> s;
cout << "The longest palindrome: " << longestPalindrome(s);
return 0;
}
此外补充一种非常好的方法：
分析：有两种可能，一种是回文字符串的长度为奇数，一种是偶数的情况。i为字符串当前字符的下标。
当回文字串为奇数的时候，j表示i-j与i+j构成的回文字串长度；当回文字串长度为偶数的时候，j表示i+1左边j个字符一直到i右边j个字符的回文字串长度~~~
用maxvalue保存遍历结果得到的最大值并且输出~~
这种算法思路非常清晰且易懂
#include
using namespace std;
int main()
{
string ss;
getline(cin,ss);
int temp,maxvalue=0;
int len = ss.size()
for(int i = 0; i < len; i++)
{
temp = 1;
///回文串为奇数
for(int j = 1; j < len; j++)
{
if(i - j < 0 || i + j >= len || s[i - j] != s[i + j])
break;
temp += 2;
}
///回文串为偶数
maxvalue = temp > maxvalue ? temp : maxvalue;
temp = 0;
for(int j = 1; j < len; j++)
{
if(i - j + 1 < 0 || i + j >= len || s[i - j + 1] != s[i + j])
break;
temp += 2;
}
maxvalue = temp > maxvalue ? temp : maxvalue;
}
cout << maxvalue;
}
方法二：动态规划
下面介绍动态规划的方法，使用动态规划可以达到最优的 O(n2) 复杂度。
令 dp[i][j] 表示 S[i] 至 S[j] 所表示的子串是否是回文子串，是则为 1，不是则为 0。这样根据 S[i] 是否等于 S[j] ，可以把转移情况分为两类：
若 S[i] == S[j]，那么只要 S[i+1] 至 S[j-1] 是回文子串，S[i] 至 S[j] 就是回文子串；如果S[i+1] 至 S[j-1] 不是回文子串，则 S[i] 至 S[j] 也不是回文子串。
若 S[i] != S[j]，那么 S[i] 至 S[j] 一定不是回文子串。
由此可以写出状态转移方程：
dp[i][j]={dp[i+1][j−1],S[i]==S[j]0,S[i]!=S[j]dp[i][j]={dp[i+1][j−1],S[i]==S[j]0,S[i]!=S[j]
边界：dp[i][i]=1，dp[i][i+1] = (S[i] == S[i+1]) ? 1 : 0。
根据递推写法从边界出发的原理，注意到边界表示的是长度为 1 和 2 的子串，且每次转移时都对子串的长度减了 1，因此不妨考虑按子串的长度和子串的初始位置进行枚举，即第一遍将长度为 3 的子串的 dp 值全部求出，第二遍通过第一遍结果计算出长度为 4 的子串的 dp 值 ……
算法时间复杂度为O(N ^ 2)。
/*
最长回文子串
*/
#include
#include
#include
#include
#include
#include
#define maxn 1010
char S[maxn];
int dp[maxn][maxn];
int main() {
gets(S); // 输入整行字符
int len=strlen(S), ans=1; // ans 记录最长回文子串长度
int i, j, L;
// 边界
for(i=0; i
方法三：中心扩展法
中心扩展就是把给定的字符串的每一个字母当做中心，向两边扩展，这样来找最长的子回文串。算法复杂度为O(N^2)。
需要考虑两种情况：
长度为奇数的回文串，比如a, aba, abcba
长度为偶数的回文串，比如aa, abba
本法借鉴一位大佬的博客：https://www.jianshu.com/p/c82cada7e5b0
给出算法代码，关于此题实现还没来得及写。
#include
#include
using namespace std;
string longestPalindrome(string &s)
{
const int len = s.size();
int maxlen = 1;
int start = 0;
for(int i = 0; i < len; i++)//求长度为奇数的回文串
{
int j = i - 1, k = i + 1;
while(j >= 0 && k < len && s.at(j) == s.at(k))
{
if(k - j + 1 > maxlen)
{
maxlen = k - j + 1;
start = j;
}
j--;
k++;
}
}
for(int i = 0; i < len; i++)//求长度为偶数的回文串
{
int j = i, k = i + 1;
while(j >= 0 && k < len && s.at(j) == s.at(k))
{
if(k - j + 1 > maxlen)
{
maxlen = k - j + 1;
start = j;
}
j--;
k++;
}
}
return s.substr(start, maxlen);
}
int main()
{
string s;
cout << "Input source string: ";
cin >> s;
cout << "The longest palindrome: " << longestPalindrome(s);
return 0;
}
作者：海天一树X
链接：https://www.jianshu.com/p/c82cada7e5b0
來源：简书
简书著作权归作者所有，任何形式的转载都请联系作者获得授权并注明出处。 方法四:Manacher算法 (马拉车)
参考我的这篇博文即可：https://blog.csdn.net/weixin_42110638/article/details/83588967
实现代码
#include
using namespace std;
const int maxn =1e6;
string str;
string s_new;
int len[maxn<<1];
int init(string st)
{
int len = st.size();
s_new='$';
for(int i =1; i <= 2*len; i+=2)
{
s_new += '#';
s_new += st[i/2];
}
s_new+='#';
s_new+='\0';
return 2*len+1;// 返回 s_new 的长度
}
int Manacher(string st,int len_)
{
int mx = 0,ans = 0,po =0;//mx即为当前计算回文串最右边字符的最大值
for(int i =1; i <= len_ ; i++)
{
if(mx>i)
len[i]=min(mx-i,len[2*po-i]);
else
len[i]=1;//如果i>=mx，要从头开始匹配
while(st[i-len[i]]==st[i+len[i]])
len[i]++;
if(len[i]+i>mx)//若新计算的回文串右端点位置大于mx，要更新po和mx的值
{
mx = len[i]+i;
po = i;
}
ans = max(ans,len[i]);//返回Len[i]中的最大值-1即为原串的最长回文子串额长度
}
return ans - 1;
}
int main()
{
getline(cin,str);
int l = init(str);
cout<