最长回文子串求解

方法一：暴力解法

思路：颠倒遍历查看

时间复杂度O(n^3)

class Solution {//暴力算法
public:
    string longestPalindrome(string s) 
    {
        if(s.size() == 0 || s.size() < 2) return s;
        int max = 0;
        string ret = "";
        for(int i = 0;i < s.size();i++)
        {
            for(int j = 1;j < s.size();j++)
            {
                string tmp = s.substr(i,j-i+1);
                string tmpr(tmp);//这里将这个子串反转一下与原串对比是否相同
                reverse(tmp.begin(),tmp.end());
                if(tmp == tmpr && tmp.size() > max)
                {
                    max = tmp.size();
                    ret = s.substr(i,j-i+1);
                }
            }
        }
        return ret;
    }
};

方法二：中心扩散算法

思路：关注左右对称，以中间之数为研究对象，往左右两边扩散。

时间复杂度：O(n^2）

class Solution {//中心扩散法
public:
    int max = 0;
    string ret = "";
    void spread(string& s,int left,int right)
    {
        int L = left,R = right;
        while(L >= 0 && R < s.size() && s[L] == s[R]) 
        {//向左向右扩散
            if(R-L+1 > max) 
            {
                max = R-L+1;
                ret = s.substr(L,R-L+1);
            }
            L--; R++;
        }
    }
    string longestPalindrome(string s) 
    {
        if(s.size() <= 1) return s;
        for(int i = 0;i < s.size();i++) 
        {
            spread(s,i,i);//从单个字符开始扩散
            spread(s,i,i+1);//从相邻的两个字符开始扩散
        }
        return ret;
    }
};

方法三：动态规划

思路：一个子串是否为回文串可以判断这个子串的第一个与最后一个是否相等+中间的子串是否为回文，中间的子串又可以分解为第一个与最后一个是否相等+中间的子串是否为回文，所以我们就找到了最优子结构，我们直接贴代码来分析

时间复杂度：O(N^2)

class Solution {//动态规划
public:
    string longestPalindrome(string s) 
    {
        if(s.size() == 0) return s;
        int dp[s.size()][s.size()] = {0};//创建一个存放状态的数组
        string ret = "";
        int max = 0;
        for(int i = 0;i < s.size();i++) 
        {//这个双循环是在判断i到j位置的子串是否为回文串
            for(int j = 0;j <= i;j++) 
            {
                dp[i][j] = s[i] == s[j] && (i-j <=2 || dp[i-1][j+1]);
                //i-j <=2这句是因为如果子串为bb时就是极限状态，他也构成回文
                //dp[i-1][j+1]这句就是判断中间的子串是否为回文，很好理解
                if(dp[i][j]) 
                {
                    if(i-j+1 > max) 
                    {
                        max = i-j+1;
                        ret = s.substr(j,i-j+1);
                    }
                }
            }
        }
        return ret;
    }
};

方法四：马拉车算法（Manacher‘s Algorithm）

马拉车算法的解释
思路：用一个Len[i]数组去存第i个位置到mx位置的长度，然后用id记录上一次操作的位置，mx标记上一次的最长子串的最右端，然后依次去递推。本质上是对中心扩散算法的优化算法。
时间复杂度：O(n).

#include <vector>
#include <iostream>
#include <string>
using namespace std;

string Mannacher(string s)
{
    //插入"#"
    string t="$#";
    for(int i=0;i<s.size();++i)
    {
        t+=s[i];
        t+="#";
    }
    
    vector<int> p(t.size(),0);
    //mx表示某个回文串延伸在最右端半径的下标，id表示这个回文子串最中间位置下标
    //resLen表示对应在s中的最大子回文串的半径，resCenter表示最大子回文串的中间位置
    int mx=0,id=0,resLen=0,resCenter=0;
     //建立p数组
    for(int i=1;i<t.size();++i)
    {
        p[i]=mx>i?min(p[2*id-i],mx-i):1;
        //遇到三种特殊的情况，需要利用中心扩展法
        while(t[i+p[i]]==t[i-p[i]])++p[i];
        //半径下标i+p[i]超过边界mx，需要更新
        if(mx<i+p[i])
        {
            mx=i+p[i];
            id=i;
        }
        //更新最大回文子串的信息，半径及中间位置
        if(resLen<p[i])
        {
            resLen=p[i];
            resCenter=i;
        }
    }
    //最长回文子串长度为半径-1，起始位置为中间位置减去半径再除以2
    return s.substr((resCenter-resLen)/2,resLen-1);
}