最长回文子串

给你一个字符串 s，找到 s 中最长的回文子串。

示例 1：

输入：s = “babad”
输出：“bab”
解释：“aba” 同样是符合题意的答案。
示例 2：

输入：s = “cbbd”
输出：“bb”

提示：

1 <= s.length <= 1000
s 仅由数字和英文字母组成

最长回文子串有多种解法，这里仅仅介绍动态规划方法，其他方法可以看参考文章。

动态规划

如果用 $f[i][j]$ 保存子串从 i 到 j 是否是回文子串，那么在求$ f[i][j] $的时候如果$ j-i>=2$ 时，且 $f[i][j]$ 为回文，那么 $f[i+1][j-1]$，也一定为回文，否则 $f[i][j] $不为回文。如下图：

因此得动态转移方程：

从动态转移方程可知，只需要二维数组 $f[i][j](0<=i<=j<s.length())$ 的一半来记录子串从 i 到 j 是否为回文串即可，并且上一行的值又依赖下一行的值(可以拿一个字符串和它的矩阵想象一下，长串依赖它的子串对应到矩阵就是上一行依赖下一行)，因此二维数组行从下向上推导，代码如下：

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

参考文章中的动态规划代码做了优化，这个完全按照递推公式来的。

参考

https://www.cnblogs.com/champock/articles/15431349.html#manacher%E7%AE%97%E6%B3%95

ttps://www.cnblogs.com/champock/articles/15431349.html#manacher%E7%AE%97%E6%B3%95