LeetCode 5. 最长回文子串 **

给定一个字符串 s，找到 s 中最长的回文子串。你可以假设 s 的最大长度为 1000。
回文：字符串对称。“abba” "aba"

测试用例

示例1：

输入: “babad”
输出: “bab”
注意: “aba” 也是一个有效答案。

示例2：

输入: “abbc”
输出: “bb”

解题思路

动态规划
对于一个子串而言，如果它是回文串，并且长度大于 2，那么将它首尾的两个字母去除之后，它仍然是个回文串。例如对于字符串 “ababa”，如果我们已经知道 “bab” 是回文串，那么 “ababa” 一定是回文串，这是因为它的首尾两个字母都是 “a”。

根据这样的思路，我们就可以用动态规划的方法解决本题。我们用 P(i, j) 表示字符串 s 的第 i 到 j 个字母组成的串（下文表示成 $s[i:j]$）是否为回文串：

$P(i,j)=\{\begin{array}{l}true,如果子串S_i...S_j是回文串\\ false,其它情况\end{array}$
这里的「其它情况」包含两种可能性：

• $s[i,j]$ 本身不是一个回文串；

• i > j，此时 $s[i,j]$ 本身不合法。

那么我们就可以写出动态规划的状态转移方程：
$P(i,j)=P(i+1,j-1)\wedge (S_i==S_j)$
也就是说，只有 $s[i+1:j-1]$是回文串，并且 s 的第 i 和 j 个字母相同时，$s[i,j]$才会是回文串。

我们还需要考虑动态规划中的边界条件，即子串的长度为 1 或 2。

• 对于长度为 1 的子串，它显然是个回文串；
• 对于长度为 2 的子串，只要它的两个字母相同，它就是一个回文串。
  因此我们就可以写出动态规划的边界条件：
  $\{\begin{array}{l}P(i,j)=true\\ P(i,i+1)=(S_i==S_{i+1})\end{array}$
  根据这个思路，我们就可以完成动态规划了，最终的答案即为所有 P(i, j) = true 中 j − i + 1（即子串长度）的最大值。
  注意：在状态转移方程中，我们是从长度较短的字符串向长度较长的字符串进行转移的，因此一定要注意动态规划的循环顺序。
  由$P(i+1,j-1)$的状态 ⇒ $P(i,j)$的状态。

Code

class Solution {
    public String longestPalindrome(String s) {
        int n = s.length();
        if (n < 2) {
            return s;
        }
        int max = 1,p = 0;
        // dp[i][j] 表示 s[i, j] 是否是回文串
        boolean[][] dp = new boolean[n][n];
        char[] charArray = s.toCharArray();

        for (int i = 0; i < n; i++) {
            dp[i][i] = true;
        }
        //注意循环顺序 从上到下 从左到右
        for (int j = 1; j < n; j++) {
            for (int i = 0; i < j; i++) {
                if (charArray[i] != charArray[j]) {
                    dp[i][j] = false;
                } else {
                    if (j - i < 3) {
                        dp[i][j] = true;
                    } else {
                        dp[i][j] = dp[i + 1][j - 1];
                    }
                }
                if (dp[i][j] && j - i + 1 > max) {
                    max =  j - i + 1;
                    p = i;
                }
            }
        }
        return s.substring(p, p + max);
    }
}

复杂度分析

• 时间复杂度：$O(n^2)$，其中 n 是字符串的长度。动态规划的状态总数为 $O(n^2)$，对于每个状态，我们需要转移的时间为 O(1)。
• 空间复杂度：$O(n^2)$，即存储动态规划状态需要的空间。