LeetCode——第五天（最长回文子串）

LeetCode——第五天

5.最长回文子串

给定一个字符串 s，找到 s 中最长的回文子串。你可以假设 s 的最大长度为 1000。

示例 1：

输入: "babad"
输出: "bab"
注意: "aba" 也是一个有效答案。
示例 2：

输入: "cbbd"
输出: "bb"

分析：自己只能想到暴力破解，三个循环，分割子串，然后判断是否是回文。看了题解，感觉一种反转的思路，其实想到了，就是要处理改进才行。还有动态规划，下面给的动态规划的方法，好理解一些，其实背包问题，挺好的。

代码：

class Solution {
public:
    string longestPalindrome(string s) {
        int n=s.size();
        string res="";
        int l=0;  //l用来记录当前最长的回文子串
        if (s.size()==0) return res;
        if(s.size()==1)return s;
        res=s[0];//返回子串初始化为第一个元素
        vector<vector<bool>> dp(n, vector<bool>(n));//定义二维数组
          for (int j = 0; j<n; j++) {
            for (int i=j;i>=0;i--){
                if((s[i] == s[j]) && (j - i <= 2 || dp[i + 1][j - 1])){  //如果两边相同，则除去两端，判断剩下是否相同，如果是，那当前二维数组标记为真
                    dp[i][j]=true;
                    if(j-i>l){  //判断最长回文子串
                        res=s.substr(i,j-i+1);
                        l=j-i;
                    }
                }
            }
        }
        return res;
    }
};

动态规划还可以减少空间，就是数组变成一维，背包问题里有。下面这个中心扩展法也很直接，就是选取中心点，主要问题是奇偶数问题，因此每一次都要奇偶都判断。

中心扩展法

class Solution {
public:
    string longestPalindrome(string s) {
        int len=s.size();
        if(len==0||len==1)
            return s;
        int start=0;//记录回文子串起始位置
        int end=0;//记录回文子串终止位置
        int mlen=0;//记录最大回文子串的长度
        for(int i=0;i<len;i++)
        {
            int len1=expendaroundcenter(s,i,i);//一个元素为中心
            int len2=expendaroundcenter(s,i,i+1);//两个元素为中心
            mlen=max(max(len1,len2),mlen);
            if(mlen>end-start+1)
            {
                start=i-(mlen-1)/2;//记录最长回文子串起始位置
                end=i+mlen/2;
            }
        }
        return s.substr(start,mlen);
        //该函数的意思是获取从start开始长度为mlen长度的字符串
    }
private:
    int expendaroundcenter(string s,int left,int right)
    //计算以left和right为中心的回文串长度
    {
        int L=left;
        int R=right;
        while(L>=0 && R<s.length() && s[R]==s[L])
        {
            L--;
            R++;
        }
        return R-L-1;
    }
};

上面的算法都只能做到O(n^2)，下面神奇的Manacher算法，可以把时间复杂度降低到O(n)，附上链接，这个解释很详细，很容易理解，而且其他解法也有。

Manacher

Manacher（马拉车）

class Solution {
public:
    string longestPalindrome(string s)
    {
        int len = s.length();
        if (len < 1)
        {
            return "";
        }

        // 预处理
        string s1;
        for (int i = 0; i < len; i++)
        {
            s1 += "#";
            s1 += s[i];
        }
        s1 += "#";

        len = s1.length();
        int MaxRight = 0;				// 当前访问到的所有回文子串，所能触及的最右一个字符的位置
        int pos = 0;					// MaxRight对应的回文串的对称轴所在的位置
        int MaxRL = 0;					// 最大回文串的回文半径
        int MaxPos = 0;					// MaxRL对应的回文串的对称轴所在的位置
        int* RL = new int[len];			// RL[i]表示以第i个字符为对称轴的回文串的回文半径
        memset(RL, 0, len * sizeof(int));
        for (int i = 0; i < len; i++)
        {
            if (i < MaxRight)
            {// 1) 当i在MaxRight的左边
                RL[i] = min(RL[2 * pos - i], MaxRight - i);
            }
            else
            {// 2) 当i在MaxRight的右边
                RL[i] = 1;
            }


            // 尝试扩展RL[i]，注意处理边界
            while (i - RL[i] >= 0  // 可以把RL[i]理解为左半径,即回文串的起始位不能小于0
                && i + RL[i] < len // 同上,即回文串的结束位不能大于总长
                && s1[i - RL[i]] == s1[i + RL[i]]// 回文串特性，左右扩展，判断字符串是否相同
                )
            {
                RL[i] += 1;
            }

            // 更新MaxRight, pos
            if (RL[i] + i - 1 > MaxRight)
            {
                MaxRight = RL[i] + i - 1;
                pos = i;
            }

            // 更新MaxRL, MaxPos
            if (MaxRL <= RL[i])
            {
                MaxRL = RL[i];
                MaxPos = i;
            }
        }
        return s.substr((MaxPos - MaxRL + 1) / 2, MaxRL - 1);
    }
};

2.总结

暴力到马拉车，复杂度n^3到n，确实神奇