最长回文字符串

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

示例 1：

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

示例 2：

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

解析：最长回文字符串就是正过来和反过来一样的字符串，比如上海自来水来自海上，小明到操场操到天明。。

方法一：从最暴力的方法入手，直接遍历所有的子字符串

class Solution {
public:
    string longestPalindrome(string s) {
        //暴力解法
        int length = s.length();
        int max = 0;
        string res = "";
        for(int i = 0; i < length; i++){
            for(int j = i + 1; j <= length; j++){
                string tmp = string(s, i, j - i);
                //cout << tmp << endl;
                if(isPalindrome(tmp) && tmp.length() > max){
                    //cout << tmp << endl;
                    max = tmp.length();
                    res = tmp;
                }
            }
        }
        return res;
        
    }

    bool isPalindrome(string s){
        for(int i = 0; i < s.length() / 2; i++){
            if(s[i] != s[s.length() - i - 1]){
                return false;
            }
        }
        return true;
    }
};

分析：遍历子字符串需要n（n - 1）/2，复杂度为O(n^2)，每次判断是否为回文字符串的复杂度为O(n)，所以，此算法复杂度为O(n^3);

方法二：通过字符串翻转，然后找到最长公共字串，再判断是否是回文字串

class Solution {
public:
    string longestPalindrome(string s) {
        string s_resvere = s;
        reverse(s_resvere.begin(), s_resvere.end());  // 翻转字符串
        return findlongestSubStr(s, s_resvere, s.length());
    }

    string findlongestSubStr(string s1, string s2, int length){
        bool check = 0;
        string res;
        for(int step = length; step > 0; step--){
            for(int i = 0; i + step - 1 < length; i++){
                string tmp = string(s1, i, step);  //定义一个临时变量，从i下标开始，往后加step个字符串
                if(s2.find(tmp) != -1){
                    string rtmp = tmp;
                    reverse(rtmp.begin(), rtmp.end());
                    if(rtmp == tmp){
                        res = tmp;
                        check = 1;
                        break;
                    }
                }
            }
            if(check) break;
        }
        return res;
    }
};

分析：此算法的时间复杂度仍然为o(n^3);

 方法三：动态规划，通过动态规划存放之前比较的结果，从而将时间复杂度缩减至O(n^2)

class Solution {
public:
    string longestPalindrome(string s) {
        int length = s.length();
        if(length <= 1) return s;
        int max = 1;  //代表最大回文串长度
        int start = 0; //代表回文串的起始下标
        int dp[1000][1000] = {0}; // 定义一个二维数组，初始化为0，dp[i][j]=1代表从 从i 到 j闭区间内为回文串
        for(int i = 0; i < length; i++){   // 进行初始化，如果为dp[i][i]一定为回文串，置为1，同样，两个连续的相同的字符也能组成一个回文串
            dp[i][i] = 1;
            if(i < length - 1 && s[i] == s[i + 1]) {
                start = i;
                max = 2;
                dp[i][i + 1] = 1;
            }
        }
        for(int size = 3; size <= length; size++){ //之前从2 判断过了， 所以从3开始进行判断
            int right;
            for(int left = 0; left + size - 1< length; left++){
                right = left + size - 1;
                if(s[left] == s[right] && dp[left + 1][right - 1] == 1){ // 如果左边等于右边，而且中间还是回文串，那么这个[left,right]一定是回文串
                    dp[left][right] = 1;
                    max = size;
                    start = left;
                }
            }
        }
        return s.substr(start, max);
    }
};

 方法四：中心扩展算法，通过中心扩展，减少相应的迭代步骤，降低时间复杂度。具体实现：一个回文串的中心可能是一个字符，也可能是两个字符，如果以一个字符为中心，有n个中心，以两个字符为中心，就有n-1个中心，所以一共有2n-1个中心；

class Solution {
public:  
    string longestPalindrome(string s) {
        int length = s.length();
        if(length <= 1) return s;
        int max_res = 1;
        int start = 0;
        for(int i = 0; i < length; i++){
            int max1 = maxLength(s, i, i);
            int max2 = maxLength(s, i, i + 1);
            if(max_res < max(max1, max2)){
                max_res = max(max1, max2);
                start = i - (max_res - 1) / 2;
                //cout << "max = "<< max_res << " " <<" start = " << start << " i = " << i <<endl;
            }
        }
        return s.substr(start, max_res);
    }

private:
    int maxLength(string s, int left, int right){  
        while(left >= 0 && right < s.length() && s[left] == s[right]) {
            left--;
            right++;
        }
        return right - left - 1;
    }
};