leetcood-5最长回文子串

class Solution {
public:
    string longestPalindrome(string s) {//暴力搜索法
        if(s.size()<2){
            return s;
        }
        
        string result = s.substr(0,1);
        string temp;
        string temp1;
        cout <<s.size()<<endl;

        for(int i=0;i<s.size();i++){//遍历每一个起点
            for(int j=s.size()-i;j>0;j--){//遍历每一个可能的终点
                if(j<result.size()) break;
                
                temp = s.substr(i, j);
                temp1 = temp;
                reverse(temp1.begin(),temp1.end()); // 对截取后的字符串进行反转
                cout <<temp<<endl;

                if (temp==temp1 && temp.size() > result.size()){
                    result = temp;
                }
            }
        }
        return result;
    }
};

暴力搜索法，最后一个999长度实例会超时。

注意语法：

1、字符串反转使用reverse（s.begin(),s.end()）;

2、判断字符串是否相等，用s==s1

3、对每个子字符串求反转判断是否相等可以判断是否为回文字符，但是对整个字符串反转求最长公共子串则未必是最长回文子串，例如S=“abacdfgdcaba”, S' = {“abacdgfdcaba”} 之间的最长公共子串为 {“abacd”}“abacd”。显然，这不是回文。

 

class Solution {
public:
    string longestPalindrome(string s) {
        int len = s.size();
        if(len==0||len==1)
            return s;
        int start = 0;//回文串起始位置
        int max=1;//回文串最大长度
        vector<vector<int> > dp(len,vector<int>(len));//定义二维动态数组len*len
        for(int i=0;i<len;i++){//初始化状态
            dp[i][i]=1;
            if(i<len-1 && s[i]==s[i+1]){//两个连续相同字符
                dp[i][i+1]=1;
                max=2;
                start=i;
            }
        }
        for(int l=3;l<=len;l++){
            for(int i=0;i+l-1<len;i++){
                int j=l+i-1;//终止字符位置
                if(s[i]==s[j]&&dp[i+1][j-1]==1)//状态转移
                {
                    dp[i][j]=1;
                    start=i;
                    max=l;
                }
            }
        }
        return s.substr(start,max);//回文子串
    }
};

除了暴力查找，首先是动态规划方法。

执行用时 :216 ms, 在所有 C++ 提交中击败了40.42%的用户

内存消耗 :186.6 MB, 在所有 C++ 提交中击败了10.97%的用户

1、首先单个字符是回文字符

2、其次两个相同字符属于回文字符

3、三个以上长度的回文需判断是s[i]==s[j] &&s[i++]==s[j--]

4、时间复杂度：O(n^2)

空间复杂度：O(n^2)存储表

 

中心扩展法：

执行用时 :112 ms, 在所有 C++ 提交中击败了51.79%的用户

内存消耗 :104.1 MB, 在所有 C++ 提交中击败了25.99%的用户

class Solution { 
public:
    string longestPalindrome(string s) {
        if(s.size()<2)
            return s;
        int maxlength=0;
        int center=0;
        for(int i=0;i<s.size();i++){
            int odd = centerExpands(s,i,i);
            int even = centerExpands(s,i,i+1);
            
            if(maxlength<max(odd,even)){
                center = i;
                maxlength=max(odd,even);
            }
        }
        return s.substr(center-(maxlength-1)/2,maxlength);
    }

private:
    int centerExpands(string s, int begin, int end){
        int left = begin, right = end;
        while (left >= 0 && right < s.size() && s[left] == s[right]){
            left--;
            right++;
        }
        // 返回以begin,end为基准，同时向左向右扩展后能够得到的最长回文串长度
        return right - left - 1;
    }

};