LeetCode0005-最长回文子串

import java.util.HashMap;

//方法一：暴力破解法
public class Num005_longestPalindromicSubstring {
    public static String longestPalindrome(String s) {
        int n = s.length();
        if(n<=1){return s;}


////        关于如何保留最大串的这里可以优化，不需要额外的hashMap。像这种只需要返回一个变量的，都可以通过设定一个最大值就可以解决
//        int max =0;int length = 0;
//        HashMap<Integer,Integer> result = new HashMap<>();
//        for(int i=0;i<n;i++){
//            for(int j=i;j<n;j++){
//
//                if(isHui(s,i,j)){
//                    length=j-i+1;
//                    result.put(length,i);
//                    max = Math.max(max,length);
//                }
//
//            }
//        }
//        //注意：substring 是 左包右不包
//        String result1=s.substring(result.get(max),result.get(max)+max);
//        return result1;

        int max =0;String ans =" ";
        for(int i=0;i<n;i++){
            for(int j=i;j<n;j++){
                if (isHui(s,i,j)&&(j-i+1)>max){
                    ans = s.substring(i,j+1);  //注意，substring左包右不包
                    max = j-1+1;
                }
            }

            }

        return ans;

    }

    public static Boolean isHui(String s ,int start ,int end){
        for(int i =start,j=end ;i<= end && j>=i ; i++,j-- ){
            // int j = end-start-i;
            if(s.charAt(i)!=s.charAt(j)){
                return false;
            }

        }
        return true;
    }

    public static void main(String[] args) {
        String s = "babad";
        String result = longestPalindrome(s);
        System.out.println(s.substring(1,4));

    }
}

 动态规划法：

用dp[i][j]来记录s[i..j]（字符串s从第i位开始到第j位是否为回文子串）

class Solution {

     public static String longestPalindrome(String s) {
         int len = s.length();
        // 长度为1的字符串一定是回文
         if(len<2) return s;
         
         int maxLen =1;
         int begin =0;

         //dp[i][j]表示s[i~j]是否为回文
         boolean[][] dp = new boolean[len][len];
         
         //初始化,长度为1的子串一定是回文子串        
         for(int i =0;i<len;i++){
             dp[i][i] = true;
         }
        //把字符串转为char数组进行处理
         char[] chars = s.toCharArray();

         // 先枚举子串长度 L ,从2到len
         for(int L=2;L<=len;L++){
             for(int i =0;i<len;i++){
                 //根据L 和i可以确定右边界;
                 int j = i+L-1;
                 //右边界越界，就退出当前循环
                 if(j >=len){ break;}
                //从最左边的列开始
                if(chars[i]!= chars[j]){
                    dp[i][j]=false;
                }else{
                    // j-i=2,为 aba这种，一定是回文；j-i=1时，是bb这种，两个相同的字符；j-i=0时，是b这种，本身；
                    if(j-i<3){
                        dp[i][j] = true;
                    }else{
                        dp[i][j]= dp[i+1][j-1];
                    }
                }
                //如果dp[i][j]是true，则是s[i~j]是回文，记录最长长度以及起始点即可
                if(dp[i][j] && j-i+1 > maxLen){
                    maxLen = j-i+1;
                    begin =i;
                }
             }
         }

        return s.substring(begin,begin+maxLen);

     }

}