5. 最长回文子串

一、题意
给定一个字符串 s，找到 s 中最长的回文子串。你可以假设 s 长度最长为1000。

示例:

输入: “babad”

输出: “bab”

注意: “aba”也是有效答案

示例:

输入: “cbbd”

输出: “bb”
二、分析和解答
1、首先暴力破解法。对该字符串的每一个子串进行回文判断，并记录当前的最大长度和子串内容，返回最长子串即可。代码如下：

    boolean isPalindrome(String str){
        boolean flag = true;
        for(int i=0,j=str.length()-1;i<=j;i++,j--){
            if(str.charAt(i) != str.charAt(j)){
                flag = false;
            }
        }
        return flag;
    }
    public String longestPalindrome(String s) {
        int max = 0;
        String res = "";
        if(s.length() == 1)
            res = s;
        for(int i=0;i<s.length();i++)
            for(int j=i;j<s.length();j++){
                String str = s.substring(i,j+1);
                if(isPalindrome(str))
                    if(max < str.length()){
                        max = str.length();
                        res = str;
                    }
            }

        return res;
    }

毫无意外，超时了！毕竟三层循环！
2、第二种方法，设置两个指针，从当前位置来找，会遇到两种情况：
（1）从当前位置向两边移动，如果相同，向两边移动，不同就结束，eg：bab（注意，不过不break的话，就会超时）；
（2）从当前位置和当前位置的后面出发，作上述过程，eg：baab；代码如下：

  public String longestPalindrome(String s) {
        int max = 0;
        String res = "";
        if(s.length() == 1)
            res = s;

        for(int t=0;t<s.length();t++){
            int i=t,j=t;               
            while(i>=0  || j<s.length()){
                if(i>=0 && j<s.length() && (s.charAt(i) == s.charAt(j))){
                    int len = j - i + 1;
                    if(max < len){
                        max = len;
                        res = s.substring(i,j+1);
                    }
                    i--;
                    j++;
                }else{
                    break;
                }
            }
        }
        for(int t=0;t<s.length();t++){
            int i=t,j=t+1;             
            while(i>=0  || j<s.length()){
                if(i>=0 && j<s.length() && (s.charAt(i) == s.charAt(j))){
                    int len = j - i + 1;
                    if(max < len){
                        max = len;
                        res = s.substring(i,j+1);
                    }
                    i--;
                    j++;
                }else{
                    break;
                }
            }
        }
        return res;
    }

这个思路我已开始做优化的时候就是有的，但是总会碰到一个案例：“aaaa”或“ccc”，我是打算通过两个if判断将上述的两种情况给解决开的，但是碰到两个例子很是尴尬！所以我有添加了判断一个字符串的内容是否都为一个字符！这几个倒是通过了，但又报了一个特长的案例未通过，根本原因仍是if处理不正确。所以，在这里我学会了一招，如果情况挺少，如两种，直接把它给重复判断一次就好了。时间复杂度O(n^2)
3、使用动态规划的方法
（1）设p[i][j] 表示从下标i到小标j的字符串，若p[i][j] == true，那么这个字符串为回文字符串。
（2）若p[i][j]是回文字符串，那么p[i+1][j-1]（子串）肯定也是回文字符串。所以这样就转换为了子问题！
逻辑：首先长度为一的肯定是回文；然后长度为二的，如果两个字符相同，那肯定是回文；然后判断长度3的就根据子问题就可以了。代码如下：

   public String longestPalindrome(String s) {
        int len = s.length();
        if(len == 0)
            return s;
        int start = 0;
        int longest = 0;
        boolean p[][] = new boolean[len][len];
        p[0][0] = true;
        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;
                start = i;
                longest = 1;
            }
        }
        //一次遍历k长度的字符串
        for(int k=2;k<len;k++){
            for(int i=0;i<len-k;i++){
                int j = i + k;
                if(s.charAt(i) == s.charAt(j) && p[i+1][j-1]){
                    p[i][j] = true;
                    start = i;
                    longest = k;
                }else
                    p[i][j] = false;
            }
        }
        return s.substring(start,start+longest+1);
    }

注意：k表示每次遍历的长度，如i为0，那么长度k的话，字符串的右边就是i+k，即为j。