LeetCode-Hot100-最长回文子串

给你一个字符串 s，找到 s 中最长的回文子串。

示例 1：

输入：s = "babad"
输出："bab"
解释："aba" 同样是符合题意的答案。
示例 2：

输入：s = "cbbd"
输出："bb"
 

来源：力扣（LeetCode）
链接：https://leetcode.cn/problems/longest-palindromic-substring。

提示：

1 <= s.length <= 1000
s 仅由数字和英文字母组成

唉，这题又超时了。虽然我想不出什么好办法尽量去减少循环了。还是超时了。这是我原来的代码，两遍循环遍历子串，最后一个循环判断是否为回文串。总的时间复杂度为O(n^3)确实不小。

string longestPalindrome(string s) {
        string max = "";
        int flag = 0;
        if(s.size() == 1) return s;
        if(s.size() > 1) {
            max = s[0];
            for(int i = 0; i < s.size(); i++) {
                string strone = s.substr(i,s.size() - i);
                if (max.size() > strone.size()) break;
                for(int j = strone.size(); j > 0 ; j--) {
                    string strtwo = strone.substr(0,j);
                    int mid = strtwo.size() / 2 - 1;
                    flag = 0;
                    for(int x = mid; x >= 0; x--) {
                        if(strtwo[x] != strtwo[strtwo.size()- x - 1]){
                            flag = 1;
                            break;
                        }
                    }
                    if(flag == 0 && strtwo.size() > max.size()){
                        max = strtwo;
                        break;
                    }
                }
            }
        }
        return max;
    }

下面用官方给的解法中心拓展法，即遍历时每一个索引为中心mid，向两边拓展，直到两遍的字符不一样。但是不确定最终的回文串为奇数或者偶数，因为奇数和偶数的中位数是不一样的。其实只要开始左右同时拓展之前，只要当前字符串里全部都是同一个字符如“aaa”或者“aa”，就可以不考虑这个问题了，但是要先单方向的向左和向右分别拓展一下，这时候是拓展对比的是mid位置的数，即分别找到左边和右边和当先位置数相同的数。

class Solution {
public:
    string longestPalindrome(string s) {
               int len = 1;
        int maxLeft = 0;//记录最长回文子串的起点
        int maxlen = 0;//记录最长回文子串的长度
        for(int mid = 0; mid < s.size(); ++mid){
            int left = mid - 1;
            int right = mid + 1;
            //向左侧扩展，直到超过边界或遇到与中心字符不等跳出while循环
            while(left >= 0 && s[left] == s[mid]){
                left--;//left字符与mid字符一致，继续左移
                len++;//与mid字符一致，回文长度+1
            }
            //向右侧扩展，直到超过边界或遇到与中心字符不等跳出while循环
            while(right <= s.size() - 1 && s[right] == s[mid]){
                right++;//right字符与mid字符一致，继续右移
                len++;//与mid字符一致，回文长度+1
            }
            //同时向左右两侧扩展
            while(left >= 0 && right <= s.size() - 1 && s[left] == s[right]){
                //注意此处，在最后一次循环中，即最长回文子串索引为：i~j，此时的left=i-1，right=j+1
                left--;
                right++;
                len += 2;
            }
            if(len > maxlen){
                maxLeft = left;
                maxlen = len;
            }
            len = 1;
        }
        //返回子串,从pos位开始，长度为len
        return s.substr(maxLeft + 1, maxlen);
    }
};