求解最大回文子串是一道比较常见的算法题，回文就是正着读和反着读是一样的，例如：上海自来水来自海上。

1.暴力求解
截取每个可能的字符子串，并判断该字符串是否回文，先写一个判断回文的小函数：

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 - 1 - i)) {
    
    
            return false;
        }
    }
    return true;
}

使用两次循环，截取出所有可能出现的子串，依次判断是否回文：

public static String solution(String s) {
    
    
    int len = s.length();
    String temp = "";
    String ret = "";
    int max = 0;
    for (int i = 0; i < len; i++) {
    
    
        for (int j = i; j < len + 1; j++) {
    
    
            temp = s.substring(i, j);
            if (isPalindromic(temp) && temp.length() > max) {
    
    
                ret = temp;
                max = Math.max(max, temp.length());
            }
        }

    }
    return ret;
}

第一次在leetcode提交时，还提示超时，其实暴力求解可以优化下的，既然是求最大回文（不是所有回文子串），内层循环时可以直接在已知解的基础上截取，如果没有满足的长度直接结束。

for (int i = 0; i < len; i++) {
    
    
	for (int j = i + max; j < len + 1; j++) {
    
    ...}
}

程序不正是优化而来的吗？

2.动态规划
动态规划在我理解就是在求解过程中，后面的求解过程可以使用前面已经求解完成的解，这样可以避免重复的运算，个人感觉和尾递归的路子一样。这里的解依旧是优化暴力求解。

使用二维数组记录字符串dp[i] [j] 来记录字符串下标 i 到 j 的子串是否为回文，显然单个字符是回文，且存在：如果s[i]==s[j]，且s[i+1]==s[j-1]，那么dp[i] [j] 是回文。

基于以上，存在：
dp[i] [i] = true;
s[i] == s[j] ，j - i = 1 || j - i = 2时，dp[i] [j] = true;
s[i]==s[j]，s[i+1]==s[j-1]时， dp[i] [j] = true;

public String longestPalindrome(String s) {
    
    
    if (s.length() < 2) {
    
    
        return s;
    }
    boolean dp[][] = new boolean[s.length()][s.length()];
    for (int i = 0; i < s.length(); i++) {
    
    
        dp[i][i] = true;
    }

    int pos = 0;
    int len = 1;

    for (int i = 1; i < s.length(); i++) {
    
    
        for (int j = 0; j < i; j++) {
    
    
            if (s.charAt(j) == s.charAt(i) && (i - j < 3 || dp[j + 1][i - 1])) {
    
    
                dp[j][i] = true;
                if (i - j + 1 > len) {
    
    
                    pos = j;
                    len = i - j + 1;
                }
            } else {
    
    
                dp[j][i] = false;
            }
        }
    }
    return s.substring(pos, pos + len);
}

这样我们标记了下标 i 到 j 的字符子串是否为回文，继续向前求解时就可以利用这些已知的解，作为判断当前求解过程的依据。