Java最长回文子串

- 题目

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

- 暴力法（写的时候调试了N次，很容易就出BUG了）

class Solution {
    public String longestPalindrome(String s) {
        if(s.length()==0)
            return "";
        String max_sub_str=s.substring(0,1);
        int i=0;
        int min=i,max=i;
        while(i<s.length()){
            int j=i+1;
            while(j<s.length()){
                if(s.charAt(i)==s.charAt(j)){
                    if(isPalindromic(s.substring(i,j+1))){
                        if(j-i>=max-min){
                            max=j;
                            min=i;
                        }
                    }
                    ++j;
                }
                else
                    ++j;
            }
            ++i; 
        }
        return s.substring(min,max+1);
    }
    public boolean isPalindromic(String sub_s){
        int end=sub_s.length()-1;
        for(int i=0;i<sub_s.length()/2;++i){
            if(sub_s.charAt(i)!=sub_s.charAt(end))
                return false;
            --end;
        }
        return true;
    }    
}

- 中心拓展算法（O(n^2)，效率好一些但是我实现起来代码还是啰嗦了一点）

class Solution {
    public String longestPalindrome(String s) {
        if(s.length()==0)
            return "";
        int min=0,max=0;
        int begin=0,end=begin;
        for(int i=0;i<s.length();++i){
            if(i==0)
                continue;
            begin=i-1;
            end=i+1;
            while(begin>=0&&end<s.length()){
                if(s.charAt(begin)==s.charAt(end)){
                    if(end-begin>=max-min){
                        min=begin;
                        max=end;
                    }
                    --begin;
                    ++end;
                }]
                else
                    break;
            }
            begin=i-1;
            end=i;
            while(begin>=0&&end<s.length()){
                if(s.charAt(begin)==s.charAt(end)){
                    if(end-begin>=max-min){
                        min=begin;
                        max=end;
                    }
                    --begin;
                    ++end;
                }
                else
                    break;
            }
        }
        return s.substring(min,max+1);
    }
}

- 中心拓展算法（仿答案，效率提高了一些，但还是O(n^2)）

//减少了重复代码，但是我觉得还是原本那个好理解一些
class Solution {
    public String longestPalindrome(String s) {
        if(s.length()==0)
            return "";
        int min=0,max=0;
        for(int i=0;i<s.length();++i){
            int length1=PalindromicstringLength(s,i-1,i+1);
            int length2=PalindromicstringLength(s,i-1,i);
            int length3=Math.max(length1,length2);
            if(length3>=max-min+1){
                min=i-length3/2;
                max=i+(length3-1)/2;
            }
        }
        return s.substring(min,max+1);
    }
    private int PalindromicstringLength(String s,int left,int right){
        while(left>=0&&right<s.length()){
            if(s.charAt(left)==s.charAt(right)){
                --left;
                ++right;
                continue;
            }
            else
                break;
        }
        return right-left-1;
    }
}

- 动态规划算法（比中心拓展算法要慢很多，大约是6倍的比例）

class Solution {
    public String longestPalindrome(String s) {
        int n=s.length();
        if(n==0)
            return "";
        boolean[][] flag=new boolean[n][n];
        for(int i=0;i<n;++i){
            flag[i][i]=true;//边界1
            if(i+1<n&&s.charAt(i)==s.charAt(i+1))
                flag[i][i+1]=true;//边界2
            int temp=i;
            for(int j=i;j<n-1;++j){
                if(temp<=0)
                    break;
                if(flag[temp][j]&&(s.charAt(temp-1)==s.charAt(j+1))){
                    flag[temp-1][j+1]=true;
                    if(flag[temp][j+1]&&j+2<n&&(s.charAt(temp-1)==s.charAt(j+2))){
                        flag[temp-1][j+2]=true;
                    }
                    --temp;

                }
            }
        }
        int max=1,left=0,right=0;
        for(int i=0;i<n;++i)
            for(int j=i;j<n;++j){
                if(j-i+1>=max&&flag[i][j]){
                    max=j-i+1;
                    left=i;
                    right=j;
                } 
            }
        return s.substring(left,right+1);
    }
}