5. 最长回文子串

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

示例 1：
输入：s = “babad”
输出：“bab”
解释：“aba” 同样是符合题意的答案。
示例 2：
输入：s = “cbbd”
输出：“bb”
提示：
1 <= s.length <= 1000
s 仅由数字和英文字母组成

解题思路一：
动态规划法“：
要计算最长的回文子串，我们首先要明白什么是回文串，回文串就是正的和倒着读是一样的，比如：上海自来水来自海上，我们可以看到，回文串中，同时去掉一前一后还是回文串，以此类推，我们可以将一前一后一次去掉，直到最后的还是一样的，那么我们就叫这个是回文串。我们动态规划法就是这个原理，不管怎样。可以依次能够计算动态方程。
提供的Java解题思路如下：

class Solution {
    public String longestPalindrome(String s) {
        if(s==null || s.length()<2){
            return s;
        }
        int strlen=s.length();
        int maxstart=0;
        int maxend=0;
        int maxlen=1;
        boolean[][] dp= new boolean[strlen][strlen];
        for(int r=1;r<strlen;r++){
            for(int l=0;l<r;l++){
                if(s.charAt(l)==s.charAt(r) && (r-l <=2 || dp[l+1][r-1])){
                    dp[l][r]=true;
                    if(r-l+1>maxlen){
                    maxlen=r-l+1;
                    maxstart=l;
                    maxend=r;
                    }
                }
            }
        }
        return s.substring(maxstart,maxend+1);
        // return maxlen;
    }
}

解题思路二：
中心扩散法：
就是从中心出发，依次向两边扩散，如果相近的都是相同的，那么就是回文串。不断的向两边扩散，然后比较，将最长的取出就是最长的回文串。
这个和动态规划是类似的，动态规划是自底向上，而中心扩散是从中心扩散走向两边。

class Solution {
    public String longestPalindrome(String s) {
        if(s==null ||s.length()==0)
        return "";
        int strlen=s.length();
        int left=0;
        int right=0;
        int len=1;
        int maxStart=0;
        int maxLen=0;

        for(int i=0;i<strlen;i++){
            left=i-1;
            right=i+1;
            while(left>=0&& s.charAt(left)==s.charAt(i)){
                len++;
                left--;
            }
            while(right<strlen&&s.charAt(right)==s.charAt(i)){
                len++;
                right++;
            }
            while(left>=0&&right<strlen&&s.charAt(right)==s.charAt(left)){
                len=len+2;
                left--;
                right++;
            }
            if(len>maxLen){
                maxLen=len;
                maxStart=left;
            }
            len=1;
        }
        return s.substring(maxStart+1,maxStart+maxLen+1);
    }
}