力扣5.最长回文子串

题目：传送门
**题意：**这个题给了一个字符串，然后在字符串中找到一个最长的回文子串并打印输出，首先我们要知道什么是回文串，回文串就是这个字符串的正序和逆序是相同的，例如"abba",这就是一个简单的回文串。我们可以观察这个回文串，就会发现回文串是一个对称的一个字符串，那么我们该如何在一个字符串中找到一个最长的回文串呢？我们就可以使用一种中心扩散的思想，遍历字符串，将遍历的当前位当做回文串的中心点，然后向左右两边开始扩散，我们就可以得到这个回文串，但是我也会想到，如果这个回文串是偶数呢，那么我们就要判断一下，这个字符和右边的是否相同，如果相同，哪一种方式得到回文串最长。
上代码：

class Solution {
public:
    string longestPalindrome(string s) {
        int ans=0,flag=0;
        int ansl;
        for(int i=0;i<s.size();i++){
            int l,r;
            l=i-1;
            flag=1;
            r=i+1;
            while(l>=0&&r<s.size()&&s[l]==s[r]){
                flag+=2;
                l--;
                r++;
            }
            if(flag>ans){
                ans=flag;
                ansl=l+1;
            }
            if(s[i]==s[i+1]){
                l=i-1;
                r=i+2;
                flag=2;
                while(l>=0&&r<s.size()&&s[l]==s[r]){
                flag+=2;
                l--;
                r++;
            }
            if(flag>ans){
                ans=flag;
                ansl=l+1;
            }
            }
        }
        return s.substr(ansl,ans);
    }
};

上面我们使用了中心扩散的方法，那我们有没有其他方法呢？我们能不能从外向内找呢？就是如果我们已经得到了一个回文串，例如"dbab",我们发现里面有"bab"回文串，那我们下一个可不可以直接给"d"比较呢？用这种方法来进行扩展，当然也是可行的，但是这样我们就必须用一个数组来记录他们的状态，以方便我们扩展。
上代码：

class Solution {
public:
    string longestPalindrome(string s) {
       int dp[1010][1010];
       memset(dp,0,sizeof dp);
       for(int i=0;i<s.size();i++)
           dp[i][i]=1;
        int ans=1,flag=0;
        for(int i=1;i<s.size();i++){
            if(s[i]==s[i-1]){
                dp[i][i-1]=1;
                dp[i-1][i]=1;
                if(ans<2){
                    ans=2;
                    flag=i;
                }
            }
            for(int j=0;j<i;j++){
                if(s[i]==s[j]&&dp[j+1][i-1]){
                    dp[j][i]=1;
                    dp[i][j]=1;
                    if(i-j+1>ans){
                        ans=i-j+1;
                        flag=i;
                    }
                }
            }
        }
        for(int i=0;i<s.size();i++){
            if(dp[flag][i]&&ans==abs(flag-i)+1){
                flag=min(flag,i);
                return s.substr(flag,ans);
            }
        }
        return s;
    }
};

但是这种方法并不好，首先空间我们开了一个二维数组，然后时间，我们必须记录所有的状态，因此时间复杂度也不理想。那就说明这种方法并不合适。然后我就去看了大佬写的😜，果然别人还是大佬，大佬使用动态规划的思路，大佬最外层循环是使用的L,L表示的是回文字符串的长度，首先是2,这样通过L的增加，就遍历了所有情况，果然大佬就是大佬，动态规划用的就是6，动态规划最重要的一点就是找状态方程，大佬的状态判别：

 if (s[i] != s[j]) {
                    dp[i][j] = false;
                } else {
                    if (j - i < 3) {
                        dp[i][j] = true;
                    } else {
                        dp[i][j] = dp[i + 1][j - 1];
                    }
                }

该如何找到状态方程呢，就是进行简单的状态分析，在某种情况下分析当前状态，例如当问当前字符串是否是回文串的时候，那他的子问题就是去掉两端是否是字符串，我们通过划分子问题，总结这样就可以得到状态方程。让我们看代码：

class Solution {
public:
    string longestPalindrome(string s) {
       int n = s.size();
        if (n < 2) {
            return s;
        }
        int maxLen = 1;
        int begin = 0;
        vector<vector<int>> dp(n, vector<int>(n));
        for (int i = 0; i < n; i++) {
            dp[i][i] = true;
        }
        for (int L = 2; L <= n; L++) {
        
            for (int i = 0; i < n; i++) {
               
                int j = L + i - 1;///通过L,i求j
                
                if (j >= n) {
                    break;
                }

                if (s[i] != s[j]) {
                    dp[i][j] = false;
                } else {
                    if (j - i < 3) {
                        dp[i][j] = true;
                    } else {
                        dp[i][j] = dp[i + 1][j - 1];
                    }
                }

                if (dp[i][j] && j - i + 1 > maxLen) {
                    maxLen = j - i + 1;
                    begin = i;
                }
            }
        }
        return s.substr(begin, maxLen);
    }
};