5. 最长回文子串(动态规划）

一、题目描述

给定一个字符串 s，找到 s 中最长的回文子串。你可以假设 s 的最大长度为 1000。
示例 1：
输入: “babad”
输出: “bab”
注意: “aba” 也是一个有效答案。
示例 2：
输入: “cbbd”
输出: “bb”

二、题解
方法一：动态规划
dp[i][j]表示从位置i到位置j的子串是否为回文串
如果S[i]==S[j]，那么如果 dp[i+1] [j-1]是回文串，那么dp[i][j]则为回文串
否则，一定不是回文串
状态转移方程可写为：

边界条件为长度为1的回文串和长度为2的回文串。
注意：在状态转移方程中，我们是从长度较短的字符串向长度较长的字符串进行转移的，因此一定要注意动态规划的循环顺序。

class Solution {
    public String longestPalindrome(String s) {
        int len = s.length();
        int[][] dp = new int[len][len];
        String str = s.substring(0,1);
        //取边界条件，回文串长度为1或2
        for(int i=0;i<len;i++){
            dp[i][i] = 1;
            if(i<len-1&&s.charAt(i)==s.charAt(i+1)){
                dp[i][i+1] = 1;
                if(str.length()<2)
                    str = s.substring(i,i+2);
            }
        }
        //遍历可能的回文串的长度，从3到主串的长度
        for(int L=3;L<=len;L++){
            for(int i=0;i<=len-L;i++){//i从0到len-L，
                int j = i+L-1;//i确定后j则为固定
                if(s.charAt(i)==s.charAt(j)&&dp[i+1][j-1]==1){
                    dp[i][j]=1;
                    if(str.length()<L)
                        str = s.substring(i,i+L);
                }
            }
        }
        return str;
    }
}

时间复杂度：$O(n^2)$
空间复杂度：$O(n^2)$
优化代码，使其更加简洁：

class Solution {
    public String longestPalindrome(String s) {
        int len = s.length();
        int[][] dp = new int[len][len];
        String str = s.substring(0,1);
        
        for(int L=1;L<=len;L++){
            for(int i=0;i<=len-L;i++){
                int j = i+L-1;
                if(L==1){
                    dp[i][j] = 1;
                }else if(L==2){
                    dp[i][j] = s.charAt(i)==s.charAt(i+1)?1:0;
                }else{
                    dp[i][j]=s.charAt(i)==s.charAt(j)&&dp[i+1][j-1]==1 ? 1 : 0;
                }
                if(dp[i][j]==1&&str.length()<L)
                    str = s.substring(i,i+L);
            }
        }
        return str;
    }
}

方法二：中心扩展算法
所有的状态在转移的时候的可能性都是唯一的。也就是说，我们可以从每一种边界情况开始「扩展」，也可以得出所有的状态对应的答案。

「边界情况」对应的子串实际上就是我们「扩展」出的回文串的「回文中心」。方法二的本质即为：我们枚举所有的「回文中心」并尝试「扩展」，直到无法扩展为止，此时的回文串长度即为此「回文中心」下的最长回文串长度。我们对所有的长度求出最大值，即可得到最终的答案。

class Solution {
public:
    string longestPalindrome(string s) {
        int len = s.length();
        int left = 0;
        int right = 0;
        int L=0;
        for(int i=0;i<len;i++){
            int len1 = expandAroundCenter(s,i,i);
            int len2 = expandAroundCenter(s,i,i+1);
            int L = max(len1,len2);
            
            if(L>right-left+1){
                left = i - (L-1)/2;
                right = i + L/2;
            }
        }
        
        return s.substr(left,right-left+1);
    }
    int expandAroundCenter(string s,int left,int right){
        while(left>=0&&right<s.length()&&s[left]==s[right]){
            left--;
            right++;
        }
        return right - left - 1;
    }
};