【LeetCode】5. 最长回文子串

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

示例 1：
输入：s = "babad"
输出："bab"
解释："aba" 同样是符合题意的答案。
示例 2：
输入：s = "cbbd"
输出："bb"
示例 3：
输入：s = "a"
输出："a"
示例 4：
输入：s = "ac"
输出："a"
 
提示：
1 <= s.length <= 1000
s 仅由数字和英文字母（大写和/或小写）组成

1. 暴力。暴力的思路就是对于每一个划分都去判断这是不是一个回文。这每一个划分的依据是无脑暴力n的平方复杂度，判断也需要n的复杂度，这就是n的三次方的复杂度。
2. 想到可以用动态规划，因为回文的中间任然是回文，这就减少了划分。
   动态规划的形式也是比较特别，we call it 区间型。

• 这道题一般有两种问法 。
• 一个是问你最长回文字串的长度此时只需要返回长度即可。
• 一个是问这个最长回文串是什么，这就需要我们多一步处理，当当前长度大于最大长度的时候根据左右下标更新答案。

//长度
class Solution {
public:
    int getLongestPalindrome(string A, int n) {
        // write code here
        //定义一个n*n 大小的矩阵 f[n][n]
        //f[i][j]表示s[i~j]是否是回文串j>=i
        //i==j 时 对角线为true
        //j-1==1时 相同为true 不同为false
        //当f[i+1][j-1]的时候 当A[i]==A[j]的时候构成新的回文 更新长度 不同则置为false
        //结果返回Malen
        vector<vector<bool>> f(n, vector<bool>(n,1));
        int maxlen=1;
        for(int i=n-1; i>=0; i--){
            for(int j=i; j<n; j++){
                if(i==j){
                 f[i][j]=true;
                 continue;
                }
                else if(j-i==1){
                    if(A[i]==A[j]){ 
                        f[i][j]=true;
                        maxlen=max(maxlen, 2);
                    }
                    else f[i][j]=false;
                    continue;
                }
                else{
                    if(f[i+1][j-1] && A[i]==A[j]){
                         f[i][j]=true;
                         maxlen=max(maxlen, j-i+1);
                    }
                    else f[i][j]=false;
                    //cout<<f[i][j]<<endl;
                }
            }
        }
        return maxlen;
    }
};

• 返回回文

class Solution {
public:
    string longestPalindrome(string s) {
        if(s.size()<2) return s;
       vector<vector<bool>> dp(s.size(),vector<bool>(s.size(), false));
       int len=1;
       string res;
       for(int i=0; i<s.size(); i++){
           dp[i][i]=true;
           res=s.substr(i,1);
       }
       for(int i=0; i<s.size()-1; i++){
           if(s[i]==s[i+1]){
               dp[i][i+1]=true;
               len=2;
               res=s.substr(i,len);
            }
       }
       for(int i=s.size()-2; i>=0; i--){
           for(int j=i+2; j<s.size(); j++){
               if(s[i]==s[j] && dp[i+1][j-1]){
                dp[i][j]=true;
                    if(j-i+1 > len){
                        len=j-i+1;
                        res=s.substr(i, len);
                        //cout<<i<<" "<<j<<" "<<len<<" "<<res<<endl;
                    }
               }
            }
        }
       //return res==""?s.substr(0,1):res;
       return res;
    }
};