5.最长回文子串

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

package com.likou;

/**
 * 5.最长回文子串
 * 给定一个字符串s,找到s中最长的回文子串。你可以假设s的最大长度为1000.
 * 示例1：
 * 输入："babad"
 * 输出:"bab"
 * 注意:"aba"也是一个有效的答案
 *
 * 示例2:
 * 输入:"cbbd"
 * 输出:"bb"
 */
public class day05 {

    public static void main(String[] args) {
        String s="cbbd";
        System.out.println(logestpalindrome(s));
        System.out.println(logestpalindrome2(s));
        System.out.println(logestpalindrome3(s));
        System.out.println(logestpalindrome4(s));
    }

    /**
     * 解法1:暴力破解
     * 暴力求解，列举所有的子串，判断是否为回文串，保存最长的回文串
     */
    public static String logestpalindrome(String s){
        String ans="";
        int max=0;
        int len=s.length();
        for (int i=0;i<=len-1;i++){
            for (int j=i+1; j<=len-1;j++){
                String test=s.substring(i,j);
                if(isPalindromic(test) && test.length()>max){
                    ans = s.substring(i,j);
                    max=Math.max(max,ans.length());
                }
            }
        }
        return ans;
    }
    //判断是否为回文串
    public static boolean isPalindromic(String s){
        int len=s.length();
        for (int i=0;i<len/2;i++){
            if(s.charAt(i) != s.charAt(len-i-1)){
                return false;
            }
        }
        return true;
    }
    /**
     * 解法2：最长公共子串
     * 思路:根据回文串的定义，正着和反着读一样，那我们是不是把原来的字符串倒置了，
     * 然后找出最长的公共子串即可以了。
     * 例如：S="caba",S="abac"，最长公共子串就是"aba",所以原字符串的最长回文串就是“aba”
     * 关于求最长公共子串（不是公共子序列），有很多方法，这里用动态规划的方法，
     * 整体思路就是，申请一个二维数组初始化为0，然后判断对应的字符串是否相等，相等的话，
     * arr[i][j]=arr[i-1][j-1]+1.
     * 当i=0或者j=0的时候单独分析，字符串相等的话，arr[i][j]就赋为1.
     * arr[i][j]保存的就是公共子串的长度
     */
    public static String logestpalindrome2(String s){
        if(s.equals("")){
            return "";
        }
        String origin=s;
        String reverse = new StringBuilder(s).reverse().toString();//字符串倒置
        int length=s.length();
        int[][] arr=new int[length][length];
        int maxLen = 0;
        int maxEnd=0;
        for (int i= 0;i<=length-1;i++){
            for (int j=0;j<=length-1;j++){
                if(origin.charAt(i)==reverse.charAt(j)){
                    if(i == 0 || j == 0){
                        arr[i][j] = 1;
                    }else {
                        arr[i][j] = arr[i-1][j-1]+1;
                    }
                }
                if(arr[i][j]>maxLen){
                    maxLen=arr[i][j];
                    //以i位置结尾的字符
                    maxEnd= i;
                }
            }
        }
        return s.substring(maxEnd-maxLen+1,maxEnd+1);
    }

    /**
     * 方法一优化
     * 首先定义公式 P(i,j)
     * P(i,j) = true s[i,j]是回文串
     * P(i,j) = false s[i,j]不是回文串
     * 接下来推导公式
     * P(i,j)=(P(i+1,j-1)&&S[i]==S[j])
     * 推导公式中我们可以看到，我们首先知道i+1才会知道i,所以我们只要倒置遍历就可以了，
     * 当求第i行的时候，我们只需要i+1行的信息，并且j的话，需要j-1的信息，所以和之前一样j
     * 也需要倒叙
     *
     * @param s
     * @return
     */
    public static String logestpalindrome3(String s){
        int n = s.length();
        String res = "";
        boolean[] P=new boolean[n];
        for (int i=n-1;i>=0;i--){
            for (int j = n-1;j>=i;j--){
                P[j]=s.charAt(i)== s.charAt(j) && (j-1<3|| P[j -1]);
                if(P[j] && j-i+1>res.length()){
                    res=s.substring(i,j+1);
                }
            }
        }
        return res;
    }

    /**
     * 方法4：扩展中心
     * 思路:
     * 我们知道回文串一定时对称的，所以我们可以每次循环选择一个中心，进行左右扩展，判断左右字符是否
     * 相等即可
     * 由于存在技术的字符串和偶数的字符串，所以我们需要从一个字符开始扩展，或者从两个字符之间开始扩展
     * ，所以总共有n+n-1个中心
     * @param s
     * @return
     */
    public static String logestpalindrome4(String s){
        if (s == null || s.length()<1){
            return "";
        }
        int start = 0;
        int end = 0;
        for (int i = 0;i<s.length();i++){
            int len1=expandAroundCenter(s,i,i);
            int len2=expandAroundCenter(s,i,i+1);
            int len=Math.max(len1,len2);
            if(len>end-start){
                start = i - (len-1)/2;
                end = i + len /2;
            }
        }
        return s.substring(start,end+1);
    }

    private static int expandAroundCenter(String s,int left,int right){
        int L=left;
        int R=right;
        while (L>=0 && R<s.length() && s.charAt(L)==s.charAt(R)){
            L--;
            R++;
        }
        return R - L - 1;
    }


}