方法一 暴力法

由长到短遍历所有子字符串, 若为回文字符串则返回
遍历时间复杂度O(n^2), 判断回文时间复杂度O(n),总时间复杂度为O(n^3)

class Solution {
    public String longestPalindrome(String s) {
        //从长到短截取所有子字符串
        String sub="";
        int count;
        boolean tag = false;
        for(int i = s.length(); i > 0; i--){    //i 子字符串长度
            for(int j = 0; j <= s.length() - i; j++){        //j 子字符串起始位置
                sub = s.substring(j, j + i);
                
                //判断是否是回文
                count = 0;
                for(int k = 0; k < sub.length() / 2; k++){
                    if(sub.charAt(k) == sub.charAt(sub.length() - k - 1))
                        count++;
                }
                if(count == sub.length() / 2)
                    return sub;
            }
            if(tag)
                break;
        }
        return "";
    }
}

方法二 中心扩撒发

以给定的字符为中心,向两边扩散,寻找最长的回文字符串
很明显要将回文子字符串长度分为偶数和奇数两种情况

• 奇数(如 aba) 以i为中心扩散
• 偶数(如abba) 以i和i+1为中心扩散

时间复杂度:O(n^2)

public String longestPalindrome(String s) {
    int start = 0, 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 int expandAroundCenter(String s, int left, int right) {
    while (left >= 0 && right < s.length() && s.charAt(left) == s.charAt(right)) {
        left--;
        right++;
    }
    return right - left - 1;
}

方法三 动态规划

回文字符串的子串也是一个回文, 这就是一个动态规划问题,如我们已经知道"aba"是一个回文,那么"cabac"也是一个回文

P(i, j) = true 表示字符串 S(i) 到 S(j)是一个回文
那么P(i, j) = (P(i+1, j-1) == true and S(i) == S(j))
初始条件:
　　　　P(i, i) = true
　　　　P(i, i+1) = true

时间复杂度: O(n^2)
空间复杂度: O(n^2)

class Solution {
    public String longestPalindrome(String s) {
        int len = s.length();
        int maxLen = 0;
        int start = 0;
        boolean p[][] = new boolean[len][len];
        
        if(s.length != 0)
            maxLen = 1;
        
        //初始化p[i][i] 和 p[i][i+1]
        for(int i = 0; i < len; i++){
            p[i][i] = true;
            if(i < len -1 && s.charAt(i) == s.charAt(i+1)){
                p[i][i+1] = true;
                maxLen = 2;
                start = i;
            }
            
        }
        
        for(int strlen = 3; strlen <= len; strlen++){    //窗口大小3 ~ len-1
            for(int i = 0; i <= len-strlen; i++){       //滑动窗口起始位置
                int j = i + strlen -1;                  //结束位置
                if(p[i+1][j-1] && s.charAt(i) == s.charAt(j)){
                    p[i][j] = true;
                    maxLen = strlen;
                    start = i;
                }
            }
        }
        return s.substring(start, start+maxLen);
    }
}