Leetcode5. 最长回文子串

给定一个字符串 s，找到 s 中最长的回文子串。你可以假设 s 的最大长度为 1000。

示例 1：

输入: “babad”
输出: “bab”
注意: “aba” 也是一个有效答案。
示例 2：

输入: "cbbd"5. 最长回文子串
输出: “bb”

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/longest-palindromic-substring
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

方法一：暴力破解法，也就是把所有的字串全都找出来。这种方法是从头部的字串开始找起，而不是从中间找起，所以可以从这种方法将所有的字串找出来。
找出字串的方法：用双重循环，然后就可以找出任意一个字串，接着判断这个字串是否是回文字符串。

class Solution {
    public String longestPalindrome(String s) {
        int length = s.length();
        if (length < 2) {
            return s;
        }
        int maxLen = 1;
        int begin=0;
        char[] chars = s.toCharArray();
        for (int i = 0; i < length - 1; i++) {  //枚举字串
            for (int j = i+1; j < length; j++) {
                if (count(chars, i, j) && (j - i + 1) > maxLen) { //是回文子串，并且是最长的字串，那么修改，只需要知道长度和开始的位置就行。
                    maxLen = j - i + 1;
                    begin = i;
                }
            }
        }
        return s.substring(begin, begin + maxLen);
    }
    public static Boolean count(char[] chars, int i, int j) {
        while (i < j) {
            if (chars[i] != chars[j]) {
                return false;
            }
            i++;
            j--;
        }
        return true;
    }
}

方法二：列举出所有的字串中心，这样就使得时间为O(n^2)，这种代码的精髓就是找出首尾位置，通过中心位置以及长度来计算出首尾位置。这是这道题第二重要的地方，第一重要的地方就是中心点

class Solution {
   public static String longestPalindrome(String s) {
        int length = s.length();
        if (length<2) return s;
        int end=0,begin=0;
        for (int i = 0; i < length; i++) {
            int leng1=count(s,i,i);
            int leng2=count(s, i, i + 1);
            int Len=Math.max(leng1,leng2);
            if (Len > end - begin) {
                begin=i-(Len-1)/2;
                end=i+Len/2;
            }
        }
        return s.substring(begin,end+1);
    }
    public static int count(String s, int i, int j) {
        int L = i, R = j;
        while (L >= 0 && R < s.length() && s.charAt(L) == s.charAt(R)) {
            L--;
            R++;
        }
        return R-L-1;
    }
}

方法3：动态规划。能想出这个方法是真大佬！！！ 我琢磨这种方法都琢磨了一个小时。首先这种方法的精髓就是把小问题算的结果保存下来，而避免了像暴力破解那样有很多重复的过程，下面开始一步一步分解代码

1. 首先，先把一些特殊情况给判断一下，并且初始化一些变量。
2. 然后开始分解问题
   1. 判断的顺序是一列一列的判断
   2. 对两个元素进行判断如果不相等，则在二维数组的相应角标赋发了，否则进入相等的条件
      1. 相等时，如果角标j - i ❤️，也就是说首尾中间（包括首尾）元素的个数小于4这时候，直接给二位数组的相应角标赋值true
      2. 如果角标只差大于3，说明中间是有可能存在回文子串，这时候通过看前一个二维数组的值（也就是boolens[ i - 1 ] [ j + 1 ]的值），如果这个值是true，说明字串是回文子串，反之不是。
3. 然后是长度的计算，如果当前长度大于之前的最大长度，那么就更新maxLen和begin的值

class Solution {
   public static String longestPalindrome(String s) {
        int length = s.length();
        if (length<2) return s;
        int maxLen = 1;
        int begin = 0;
        char[] arr = s.toCharArray();
        boolean[][] booleans = new boolean[length][length];
        for (int i = 0; i < length; i++) {
            booleans[i][i] = true;
        }
        for (int j = 1; j < length; j++) {
            for (int i = 0; i < j; i++) {
                if (arr[i] != arr[j]) booleans[i][j] = false;
                else{
                    if (j-i<3) booleans[i][j] = true;
                    else booleans[i][j] = booleans[i + 1][j - 1];
                }
                if (booleans[i][j] && maxLen <= j - i + 1) {
                    begin = i;
                    maxLen = j - i + 1;
                }
            }
        }
        return s.substring(begin, maxLen + begin);
    }
}