5. 最长回文子串 暴力解法 java，动态规划解法

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

示例 1：

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

示例 2：

输入：s = "cbbd"
输出："bb"

提示：

    1 <= s.length <= 1000
    s 仅由数字和英文字母组成

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

解法一：暴力解法

思路：

双重循环逐个判断符合条件的字符串，但传统的一个个判断会超时，对判断条件加以筛选，同时不需要每次截取字符串，通常记录下标，在返回时候进行字符串截取

1.字符串长度小于2一定是回文串

2.用begin记录最长字符串的起始位置，用maxlen记录长度，使用begin和begin+maxlen进行字符串截取

import java.util.*;
class Solution {
    //判断所给的串是否为回文串
    public boolean judge(char temp[],int low,int high) {
		int index=low;
        for(int i=high;i>=low;i--){
            if(temp[index++]!=temp[i]){
                return false;
            }
        }
        return true;
	}
    public String longestPalindrome(String s) {
        int len=s.length();
        if(len<2)
        return s;
        int begin=0;
        int maxlen=1;

        char[] ch=s.toCharArray();
        for(int i=0;i<len-1;i++){
            for(int j=i+1;j<len;j++){
                if(j-i+1>maxlen&&judge(ch,i,j)){
                    begin=i;
                    maxlen=j-i+1;
                }
            }
        }
       return s.substring(begin,begin+maxlen);
    }
}

解法二：动态规划

思路：

1、布尔数组dp[i][j]表示子串s【i……j】是否为回文串

2、如何生成dp[i][j]？

    2.1、当左右新加入的字符不同时，一定不为回文串，比如原串 “a” 左右新加字符后为“cab”，那这一定不为回文串,即dp[i][j]=false；

   2.2、左右新加入的字符相同时，分以下两种讨论：

         2.2.1、原串长度<2，则此时一定为回文串，比如：原串为 “a”，加入后串变为“cac”，则dp[i][j]=true;

       2.2.2、原串长度>2，则加入两个相等字符看原串的值为false还是true。比如原串为“ac"，此时原串对应的dp[i+1][j-1]=false，因为ac不是回文串，当加入了两个相同字符，比如为”bacb“，则dp[i][j]=dp[i+1][j-1]的值，即也为false；

代码：

import java.util.*;
class Solution {
   
    public String longestPalindrome(String s) {
        int len=s.length();
        if(len<2)
        return s;
        char[] ch=s.toCharArray();
        boolean[][] dp=new boolean[len][len];
        for(int i=0;i<len;i++){
            for(int j=0;j<len;j++){
                dp[i][j]=true;
            }
        }
        int begin=0;
        int maxlen=1;
        for(int j=1;j<len;j++){
            for(int i=0;i<j;i++){
                if(ch[i]!=ch[j]){
                    dp[i][j]=false;
                }else{
                    if(j-i<3){
                        dp[i][j]=true;
                    }else{
                        dp[i][j]=dp[i+1][j-1];
                    }
                }
                if(j-i+1>maxlen&&dp[i][j]){
                            maxlen=j-i+1;
                            begin=i;
                        }
            }
        }
        return s.substring(begin,begin+maxlen);
    }
}