【leetcode】最长回文子串c++

题目描述：
给你一个字符串 s，找到 s 中最长的回文子串。

示例1：

输入：s = “babad”
输出：“bab”
解释：“aba” 同样是符合题意的答案。

示例2：

输入：s = “cbbd”
输出：“bb”

示例3：

输入：s = “a”
输出：“a”

示例4：

输入：s = “ac”
输出：“a”

提示：

1 <= s.length <= 1000
s 仅由数字和英文字母（大写和/或小写）组成

代码：

class Solution {
public:
    string longestPalindrome(string s) {
        int n=s.length();
        if(n<=1)return s; //一定是回文串
        int a[n][n];
        for(int i=0;i<n;i++){
            for(int j=0;j<n;j++){
                a[i][j]=-1;
                if(i==j)a[i][j]=1;
                if(j==i+1&&s[i]==s[j]){
                    a[i][j]=1;
                }
            }
        }
        for(int i=2;i<=n;i++){ //回文串可能的长度
            for(int j=0;j<n;j++){//回文串可能的开始下标，结束下标为i+j-1
                int r = j+i-1;
                if(r>=n)break;
                else{
                    if(s[j]!=s[r])a[j][r]=-1;
                    else if(r>=j&&s[j]==s[r]){
                        if(r-j>=3){
                            a[j][r]=a[j+1][r-1];
                        }
                        else if(r-j<3){
                            a[j][r]=1;
                        }
                    }
                }
            }
        }
        int max=0,start=0;
        string ss="";
        for(int i=0;i<n;i++){
            for(int j=0;j<n;j++){
                if(a[i][j]!=-1&&j-i+1>max){
                    max=j-i+1;
                    start = i;
                }
            }
        }
        ss=s.substr(start,max);
        return ss;
    }
};

因为前后两个回文串之间存在联系，所以可借助该关系判断回文串，而不是使用双层for循环暴力解决，即使用动态规划：

用字符串的首尾字符位置来表示当前字符串，并用数组a[i][j]来表示字符串s[i,j]是否为回文串，最后只需查找a[i][j]为正时j和i的最大差值，即为最长回文串的长度。

用数组a[i][j]来表示字符串s[i,j]是否为回文串，初始化字符本身、相邻两个相同字母时，为回文串，即a[i][i]=1、a[i][i+1]=1ifs[i]=s[i+1]

所有可能的回文串长度从3到n（长度为1和2的已经在初始化中处理过了）。

①如果a[l+1][r-1]=1即s[l+1,r-1]是回文串，则当s[l]=s[r]时，s[l,r]相当于在原回文串首尾加上两个相同的字符，s[l,r]一定也是回文串；当s[l]!=s[r]时，s[l,r]一定不是回文串，s[l,r]=-1;

②如果a[l+1][r-1]=-1，s[l,r]一定不是回文串

用双层循环，外层循环遍历回文串所有可能长度i，内层循环遍历回文串所有可能的起始下标j，则对应的字符串结束下标为j+i-1，判断s[j,j+i-1]是否为回文串并赋值。

最后遍历数组a，找到最大回文串长长度输出。

动态规划中因为每次处理新的情况时都用到了之前的结果，所以避免了重复计算，减少了处理时间，不会超时。