[每日leetcode]最长回文子串

最长回文子串

给定一个字符串 s，找到 s 中最长的回文子串。你可以假设 s 的最大长度为 1000。
示例 1：
输入: “babad”
输出: “bab”
注意: “aba” 也是一个有效答案。
示例 2：
输入: “cbbd”
输出: “bb”

c++代码

方法一：暴力解法
找出所有子串判断是不是回文子串

class Solution {
public:
    string longestPalindrome(string s) {
        if(s.empty())
            return "";
        if(s.size()==1)
            return s;
        int maxlength=1,start=0;//注意回文子串的长度除了空最小也是1
        for(int i=0;i<s.size()-1;i++)
        {
            for(int j=i+1;j<s.size();j++)
            {
                int tmp1=i,tmp2=j;
                while(tmp1<=tmp2)
                {
                    if(s[tmp1]!=s[tmp2])
                        break;
                    tmp1++;
                    tmp2--;
                    
                }
                if(tmp1>tmp2)
                {
                    if(j-i+1>maxlength)
                    {
                        maxlength=j-i+1;
                        start=i;
                    }                        
                }
            }            
        }
        return s.substr(start,maxlength);//返回从start开始长度为maxlength的子串
    }
        
};

方法二：动态规划
对于字符串str，假设dp[i,j]=1表示str[i…j]是回文子串，那个必定存在dp[i+1,j-1]=1。这样最长回文子串就能分解成一系列子问题，可以利用动态规划求解了。首先构造状态转移方程

上面的状态转移方程表示，当str[i]=str[j]时，如果str[i+1…j-1]是回文串，则str[i…j]也是回文串；如果str[i+1…j-1]不是回文串，则str[i…j]不是回文串。

初始状态

• dp[i][i]=1

• dp[i][i+1]=1 if str[i]==str[i+1]

  上式的意义是单个字符，两个相同字符都是回文串。

class Solution {
public:
    string longestPalindrome(string s) {
        if(s.empty())
            return "";
        if(s.size()==1)
            return s;
        int len=s.size();
        int maxlength=1,start=0;
        vector<vector<int>> dp(len,vector<int>(len));//创建一个二维数组
        for(int i=0;i<len;i++)//初始化
        {
            dp[i][i]=1;//每单个字符都是回文的
            if(i+1<len)
            {
                if(s[i]==s[i+1])//两个相邻的相等的字符也是回文串
                {
                    dp[i][i+1]=1;
                    start=i;
                    maxlength=2;
                }       
            }
            
        }
        for(int l=3;l<=len;l++)
        {
            for(int i=0;i+l-1<len;i++)
            {
                int j=i+l-1;
                if(s[i]==s[j]&&dp[i+1][j-1]==1)
                {
                    dp[i][j]=1;
                    start=i;
                    maxlength=l;
                }
            }
        }
        return s.substr(start,maxlength);
    }
        
};

方法三：中心扩展算法
事实上，只需使用恒定的空间，我们就可以在 O(n^2)的时间内解决这个问题。
我们观察到回文中心的两侧互为镜像。因此，回文可以从它的中心展开，并且只有 2n−1 个这样的中心。你可能会问，为什么会是 2n−1个，而不是 n 个中心？原因在于所含字母数为偶数的回文的中心可以处于两字母之间（例如 “abba” 的中心在两个 ‘b’ 之间）。

class Solution {
public:
    string longestPalindrome(string s) {
        if(s.empty())
            return "";
        if(s.size()==1)
            return s;
        int n=s.size();
        int start=0,end=0;
        int maxlen=0;
        for(int i=0;i<n;i++)
        {
            int len1=toaround(s,i,i);
            int len2=toaround(s,i,i+1);
            int len=max(len1,len2);
            if(len>maxlen)
            {
                maxlen=len;
                start=i-(len-1)/2;
            }
            
        }
        return s.substr(start,maxlen);
    }
    int toaround(string s,int left,int right)
    {
        while(left>=0 && right<s.size() && s[left]==s[right])
        {
            left--;
            right++;
        }
        return right-left-1;
    }
        
};