最长回文子串

第一种

空间占用很小，但花费很多时间

class Solution {
public:
    string longestPalindrome(string s) {
        int result = 0;
        int resultGap = 0;
        int s_size = s.size();
        int l_result = 0;
        int r_result = 0;
        for(int left = 0 , right = 1; right < s.size() ; ){
            if(s[left] == s[right])
            {
                //cout<<" l = "<<s[left] << " " << left <<" r = "<<s[right]<< " " << right <<endl;
                
                int l = left;
                int r = right;
                int gap = (right -left+1)%2;
                while(s[l] == s[r]&&r>l){
                    if(s[l]==s[r]&&r==l+1&&gap==0){
                        //cout<<s.substr(left,right-left+1)<<endl;
                        result = right-left+1;
                        if(result>resultGap){
                            resultGap = result;
                            l_result = left;
                            r_result = right;
                        }
                        break;
                    }
                    if(s[l]==s[r]&&r==l+2&&gap!=0){
                        //cout<<s.substr(left,right-left+1)<<endl;
                        result = right-left+1;
                        if(result>resultGap){
                            resultGap = result;
                            l_result = left;
                            r_result = right;
                        }
                        break;
                    }
                    r--;l++;//这两必须在后面
                }
            }
            if(right == s_size-1&&left != s_size-2){
                left++;
                right = left+1;
            }else{
                right++;
            }
        }
        cout<<l_result<<" "<<r_result<<endl;
        return s.substr(l_result,r_result - l_result+1);
    }
};
//可以不可以这样检测到左指针和右指针的字符相等，就开启回文检测
//左右两个指针不停向里逼近每次左右都相等直到结束，就是回文
//上面的代码忽略了一种可能一次，那就是一次left没到倒数第二位时left和right都要重置

第二种

空间和时间占用都很小

class Solution {
public:
//返回包含两个int的数组
//
    pair<int, int> expandAroundCenter(const string& s, int left, int right) {
        while (left >= 0 && right < s.size() && s[left] == s[right]) {
            --left;
            ++right;
        }
        return {left + 1, right - 1};
    }

    string longestPalindrome(string s) {
        int start = 0, end = 0;
        for (int i = 0; i < s.size(); ++i) {

            auto [left1, right1] = expandAroundCenter(s, i, i);//s是原字符串，left和right都等于i

            auto [left2, right2] = expandAroundCenter(s, i, i + 1);//s是原字符串，left等于i，right等于i+1
            //右1减左1大于结尾减开始时
            if (right1 - left1 > end - start) {
                start = left1;
                end = right1;
                //开始赋值左1
                //结尾赋值右1
            }
            //右2减左2大于结尾减开始时
            if (right2 - left2 > end - start) {
                start = left2;
                end = right2;
                //开始赋值左2
                //结尾赋值右2
            }
        }
        return s.substr(start, end - start + 1);
    }
};
//总结起来就是随着i的前进（遍历s的位次），以i为中心向左右扩散检测回文
//left和right都等于i时检测的是长度为奇数的回文
//left等于i和right等于i+1时检测的是长度为偶数的回文
//好办法！