LeetCode代码分析——5. Longest Palindromic Substring

最简单粗暴的方法（也是Time Out的方法- -|||）

遍历s的每一个子数组，然后分别确定是不是回文，确实了是回文之后再确定是不是比当前记录要大

太蠢了，但是不失为一种方法。。。只不是Time Out 233333

public class Solution {
    public String longestPalindrome(String s) {
        String str = null;
        int maxSize = 0;
        String maxSub = s.substring(0,1);
        for(int i = 0; i < s.length(); i++){
            //j从i+1开始，因为j如果从i开始那就一个数，没有什么参考价值
            for(int j = i + 1; j < s.length(); j++){
                str = s.substring(i,j+1);
                if(isPalindrome(str) && str.length() > maxSize){
                    maxSub = str;
                    maxSize = str.length();
                }
            }
        }
        return maxSub;
    }
    
    public boolean isPalindrome(String s){
        for(int i = 0; i < s.length(); i++){
            if(s.charAt(i) != s.charAt(s.length() - i - 1)){
                return false;
            }
        }
        return true;
    }
}

另一种方法，在做的过程中发现，回文是个重叠子问题，（回文的内层是回文，回文内层的回文又是个回文，子子孙孙无穷尽也。。。）想到了DP——动态规划，至于怎么做呢，明天再弄。。

好，回来了，最基本的回文就是单个的单词(a)，其它回文都是单个单词的扩展，

可以采用动态规划的带备忘录的自顶向下的方法（或者自底向上都可以），创建一个二维布尔数组，因为单个单词都为回文，所以isPalindrome[i][i] = true;

其它的回文分为两种形式，bab和baab，

前一种bab的形式，如果中间的部分已经是回文，那么只需要检测它前一个和后一个，如果相等，那么就可以填写布尔数组，

后一种baab的形式，外层的bb是和上面一样的，但是内层的aa需要在检测单词的时候不仅检测前后是否相等；还要检测到前一个是否和该单词相等，后一个是否和该单词相等

public class Solution {
    public String longestPalindrome(String s) {
        int m = s.length();
        boolean[][] isPalindrome = new boolean[m][m];
        int maxSize = 0;
        String maxStr = null;
        //之前循环的方向错了
        //而且回文有两种，baab和bab
        for(int i = 0; i < m; i++){
            for(int a = 0; a + i < m; a++){
                int b = a + i;
                if(i == 0) isPalindrome[a][b] = true;
                if(isPalindrome[a][b]){
                    if(b - a + 1 > maxSize){
                        maxSize = b - a + 1;
                        maxStr = s.substring(a,b + 1);
                    }
                    //如果是i==0的情况，还需要检测aa,bb这样的回文
                    if(i == 0){
                        if(a - 1 >= 0 && s.charAt(a - 1) == s.charAt(a)){
                            isPalindrome[a - 1][a] = true;
                            if(2 > maxSize){
                                maxSize = 2;
                                maxStr = s.substring(a - 1,a + 1);
                            }
                        }
                        if(b + 1 < m && s.charAt(b + 1) == s.charAt(b)){
                            isPalindrome[b][b + 1] = true;
                            if(2 > maxSize){
                                maxSize = 2;
                                maxStr = s.substring(b,b + 2);
                            }
                        }
                    }
                    if(a - 1 >= 0 && b + 1 < m && s.charAt(a - 1) == s.charAt(b + 1)){
                        isPalindrome[a - 1][b + 1] = true;
                        if((b + 1) - (a - 1) + 1 > maxSize){
                            maxSize = (b + 1) - (a - 1) + 1;
                            maxStr = s.substring(a - 1,b + 2);
                        }
                    }
                }
            }
        }
        return maxStr;
    }
}

注：之前写了一半，发现循环的方式错了，如果按照第一种的那样暴力解法的循环方向的话会漏掉很多情况，

注意理解动态规划的思想，规模由小到大（例：baabcba，从规模为1的b,a,a,b,c,b,a到规模为2的ba,aa,ab,bc,cb,ba到规模为3的baa,aab,abc,bcb,cba...）

动态规划是以规模为循环变量进行的，确定了重叠子问题、找到了如何划分规模的方法也就找到了动态规划的做法。