最长回文子串（LPS）——动态规划求解

提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档

题目

回文子串是指：若某一字符串的反序与原始字符串相同，则该字符串称为回文字符串

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

示例 1：

输入：s = "babad"
输出："bab"
解释：“aba” 也是一个有效答案。

示例 ：

输入：s = "c22d"
输出："22"

提示：

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

---

提示：以下是本篇文章正文内容，下面案例可供参考

解题思路

要找到给定字符串 s 中最长的回文子串，可以采用动态规划的方法。动态规划的状态定义如下：

dp[i][j] 表示字符串 s 从索引 i 到 j 的子串是否为回文串。

初始化状态：

当 i == j 时，显然只有一个字符，所以 dp[i][i] = true。

状态转移方程：

对于 i < j 的情况，如果 s[i] 等于 s[j]，并且 dp[i + 1][j - 1] 为真（即子串 s[i+1] 到 s[j-1] 为回文串），那么 dp[i][j] 也为真。

在计算过程中，同时记录下当前找到的最长回文子串的起始索引和长度。

最后，根据最长回文子串的起始索引和长度，使用 substr 函数从原字符串 s 中提取出最长的回文子串。

以下是动态规划c++代码实现：

class Solution {
public:
    string longestPalindrome(string s) {
        int len = s.size();
        // 如果字符串长度小于2，则直接返回原字符串，因为长度为1的字符串本身就是回文串
        if (len < 2) {
            return s;
        }
        vector<vector<int>> dp(len, vector<int>(len));
        // 初始化：对于长度为1的子串，它们都是回文串，所以在 dp 数组中将对角线元素设为1
        for (int i = 0; i < len; i++) {
            dp[i][i] = 1;
        }
        string ans;
        int maxlen = 1;
        int begin = 0;
        for (int j = 1; j < len; j++) {
            for (int i = 0; i < j; i++) {
                // 若首尾字符相等，且满足以下条件之一：
                //   1. 去掉首尾字符后的子串也是回文串（dp[i + 1][j - 1] 为 true）
                //   2. 当前子串长度小于等于2（长度为2的子串只要首尾字符相等就是回文串）
                dp[i][j] = (s[i] == s[j]) && (dp[i + 1][j - 1] || (j - i + 1) < 3);
                // 若当前子串是回文串，并且其长度大于已记录的最大长度
                if (dp[i][j] && (j - i + 1) > maxlen) {
                    // 更新最长回文子串的最大长度和起始索引
                    maxlen = j - i + 1;
                    begin = i;
                }
            }
        }
        ans = s.substr(begin, maxlen);
        return ans;
    }
};

时间复杂度分析： 这段代码的时间复杂度是 O(n^2)，其中 n 是输入字符串 s 的长度。这是由于两个嵌套循环结构，外层循环遍历了字符串中每一个可能的子串终点，内层循环遍历了以该终点为结束的所有可能子串起点。因此，总共进行了大约 n*(n-1)/2 次状态的计算和判断。

空间复杂度分析： 这段代码的空间复杂度是 O(n^2)，它创建了一个 n×n 的二维动态规划数组 dp 来存储子串是否为回文串的信息。对于每一个子串，都需要存储一个布尔值，故总空间需求为 n*n。虽然实际上很多单元格并不需要存储完整的信息，但对于固定输入大小，所需空间量是固定的，因此空间复杂度仍然为 O(n^2)。