最长回文子串

DESC:

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

示例 1：

输入：s = "babad"
输出："bab"
解释："aba" 同样是符合题意的答案。

示例 2：

输入：s = "cbbd"
输出："bb"

示例 3：

输入：s = "a"
输出："a"

示例 4：

输入：s = "ac"
输出："a"

提示：

    1 <= s.length <= 1000
    s 仅由数字和英文字母（大写和/或小写）组成

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/longest-palindromic-substring
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

CODE:

JAVA:

class Solution {
    public String longestPalindrome(String s) {
        if (s == null || s.length()<2) {
            return s;
        }
        int n = s.length();
        boolean[][] dp = new boolean[n][n];
        int maxLen = 1;
        int begin = 0;
        for (int j=1; j<n; j++) {
            dp[j][j] = true;
            for (int i=0; i<j; i++) {
                dp[i][j] = s.charAt(i) == s.charAt(j) && (j-i<3 || dp[i+1][j-1]);
                if (dp[i][j] && j-i+1>maxLen) {
                    maxLen = j-i+1;
                    begin = i;
                }
            }
        }
        return s.substring(begin, begin+maxLen);
    }
}

//上三角
class Solution {
    public String longestPalindrome(String s) {
        if (s == null || s.length() <= 1) {
            return s;
        }
        int n = s.length(), maxLen = 1, start=0;
        boolean[][] dp = new boolean[n][n];
        for (int i=n-1; i>=0; i--) {
            dp[i][i] = true;
            for (int j=i+1; j<n; j++) {
                dp[i][j] = s.charAt(i) == s.charAt(j) && (j-i<=2 || dp[i+1][j-1]);
                if (dp[i][j] && (j-i+1>maxLen)) {
                    maxLen = j-i+1;
                    start = i;
                } 
            }
        }
        return s.substring(start, start+maxLen);
    }
}

Python

class Solution:
    def longestPalindrome(self, s: str) -> str:
        if not s or len(s)<=1: return s
        n = len(s)
        maxLen=1
        start=0
        dp = [[False] * n for _ in range(n)]
        for i in range(n):
            dp[i][i] = True
        i=n-1
        while i>=0:
            for j in range(i+1, n):
                dp[i][j] = s[i]==s[j] and (j-i<3 or dp[i+1][j-1])
                if dp[i][j] and j-i+1>maxLen:
                    maxLen = j-i+1
                    start = i
            i-=1
        return s[start:start+maxLen]

NOTES:

1. 动态规划
2. 布尔型dp[i][j]代表字符串区间[i,j]是否是回文串，注意限制，i<j, 所以我们只需要填充右上半三角，单个字符肯定是回文串，即dp[i][i]=true
3. 状态转移关系dp[i][j] = s.charAt(i) == s.charAt(j) && (j-i<3 || dp[i+1][j-1]); j-i<3表示在左右边界相同条件下，子串长度是2或者3肯定都是回文串，如bb,bab，否则需要判断dp[i+1][j-1]
4. 在数组中状态转移体现在当前位置依赖左下角[i+1,j-1]位置的状态，所以外循环为列， 如果想外循环为行，需要从右下角填充
5. 其它方法还有中心展，Manacher 算法

复杂度分析

    时间复杂度：O(n^2)，其中 n 是字符串的长度。

    空间复杂度：O(n2)。