动态规划学习4：5 最长回文子串 三种方法

方法一

暴力算法

class Solution {
public:

    bool if_same(string& str,int left,int right){
    while (left<=right){
        if (str[left]!=str[right]){
            return false;
        }
        left++;
        right--;
    }
    return true;
}
    string longestPalindrome(string s) {
        string res = s.substr(0,1);
    for (int i = 0; i < s.size(); i++) {
        for (int j = i+1; j < s.size(); j++) {
            if (j-i+1>=res.size()&& if_same(s,i,j)){
                res = s.substr(i,j-i+1);
            }
        }
    }
    return res;
    }
};

两层for循环，第i个元素与第j个元素中是否构成回文子串，如果对称的两边有不一样的元素直接返回false，然后继续判断i到j+1能否构成回文子串
能返回true且长度比res长就更新res
毫无感情的做题机器

方法二

动态规划

class Solution {
public:
    string longestPalindrome(string s) {
         int len = s.size();
         vector<vector<bool>> arr (len,vector<bool>(len,false));
        string str = s.substr(0,1);
        for(int i = 1;i<len;i++){
            for(int j = i-1;j>=0;j--){
                if(i==j) arr[j][i] = true;
                else if (i-j<=2&&s[i]==s[j]) 
                arr[j][i]=true;
                else if(s[i]==s[j]&&arr[j+1][i-1]){
                    arr[j][i]=true;
                }
             if(arr[j][i]&&i-j+1>str.size()){
                 str = s.substr(j,i-j+1);
             }
        }
    }
    return str;   
    }
};

大体思路：用bool类型的arr [ ] [ ]来表示i到j是否为回文串，用i和j分别向两边遍历，i向右，j从i-1的位置向左
一.确定状态
最后一步（1）当i=j时，arr[i][j] = true
（2）当j-i<=2时，即AB或者ABA类型，当s[i] == s[j]时，arr[i][j] = true
（3）当j-i>2时，当s[i]==s[j]&&arr[j+1][i-1]时，arr[i][j] = true
即要判断一串字符是否为回文串，只需要判断去掉两端剩下的字符串是否为回文串和两端的字符是否相等即可
二.转移方程
arr[i][j] = true (i = = j)
arr[i][j] = true(s[i]==s[j]&&0<j-i<=2)
arr[i][j] = true(s[i]==s[j]&&arr[j+1][i-1]==true)
判断完true后依然是继续判断这部分长度是否大于res中已经储存的回文串长度

方法三

中心扩散法

class Solution {
public:
    string res;
    string longestPalindrome(string s) {
        res = s.substr(0,1);
        int len = s.size();
        for(int i = 0;i<len;i++){
            centre(s,i,i);
            centre(s,i,i+1);
        }
        return res;
    }
    void centre(string& s,int left,int right){
        while(left >=0 && right < s.size() && s[left] == s[right]){
            left--;
            right++;
        }
        if(right-left-1>res.size()){
            res = s.substr(left+1,right-left-1);
        }
        
    }
};

只用一次for循环的算法，大体思路是从i开始向两边扩散，判断一直能扩散多少个对称的字符，然后将这个长度与res的长度作比较
值得注意的是在跳出while时left–和right++已经不符合要求了，最后判断回文串长度时要减去
因为回文串存在偶数对称和奇数对称，所以调用两遍
centre(s,i,i);
centre(s,i,i+1);