5. 最长回文子串

思路：

对于一个子串来说，如果它是回文串，并且长度大于2，那么去了首尾两个字母之后，它仍然是个回文串。
我们用P(i,j)表示字符串s的第i到第j个字母组成的串（之后用s(i:j)表示）是否为回文串。
P(i,j)= true，如果s(i:j)是回文串；
P(i,j)=false，其它情况->s(i:j)不是回文串或者i>j；
那么就可以写出动态规划的状态转移方程：
P(i,j)=P(i+1,j-1)&&(s(i)==s(j))
也就是说，如果s(i:j)为回文串，必须同时满足两个条件：1、s(i+1,j-1)为回文串；2、s(i)==s(j)即字符串的第i个字符和第j个字符相等，这是都是建立在字串长度大于2的前提之上的；
因此还需要考虑边界条件：即子串的长度为1或者2，当子串长度为1时，很显然是个回文串，即P(i,i)=true;
当字串长度为2时，当子串的第i个字符等于第i+1个字符时，才是回文串，即P(i,i+1)=(s(i)==s(i+1));
根据以上思路，就可以完成动态规划了，最终的答案即为所有的P(i,j)=true中j-i+1(即子串长度)的最大值。

代码：

	public String longestPalindrome(String s) {
        int n = s.length();
        boolean[][] dp = new boolean[n][n];
        String res = "";
        for (int l = 0; l < n; l++) {
            for (int i = 0; i + l < n; i++) {
                int j = i + l;
                if (l == 0) {
                    dp[i][j] = true;
                } else if (l == 1) {
                    dp[i][j] = s.charAt(i) == s.charAt(j);
                } else {
                    dp[i][j] = s.charAt(i) == s.charAt(j) && dp[i + 1][j - 1];
                }
                if (dp[i][j] && l + 1 > res.length()) {
                    res = s.substring(i, i + l + 1);
                }
            }
        }
        return res;
    }

补充：

中心扩散算法

	public String longestPalindrome(String s) {
        int n = s.length();
        String res = "";
        for (int i = 0; i < n; i++) {
            String str1 = getlongestPalindrome2(s, i, i);
            String str2 = getlongestPalindrome2(s, i, i + 1);
            res = str1.length() > str2.length() ? (str1.length() > res.length() ? str1 : res) : (str2.length() > res.length() ? str2 : res);
        }
        return res;
    }

    public String getlongestPalindrome(String s, int left, int right) {
        String res = "";
        while (left >= 0 && right < s.length() && s.charAt(left) == s.charAt(right)) {
            res = (right - left + 1) > res.length() ? s.substring(left, right + 1) : res;
            left--;
            right++;

        }
        return res;

    }