Leetcode 5. 最长回文子串--动态规划与中心扩展

Lafitteee拉菲

已于 2022-05-22 10:33:17 修改

阅读量895

点赞数

分类专栏：算法就是武!装!色!霸!气! 文章标签： leetcode 算法动态规划回文串

于 2022-03-19 21:29:26 首次发布

本文链接：https://blog.csdn.net/weixin_43889028/article/details/123603264

版权

算法就是武!装!色!霸!气! 专栏收录该内容

12 篇文章 0 订阅

订阅专栏

本文介绍了如何使用动态规划和中心扩展法解决寻找字符串中最长回文子串的问题。动态规划方法通过填充二维dp数组，以O(n^2)的时间复杂度和O(n^2)的空间复杂度找到答案。中心扩展法则通过枚举子串中心并扩展，同样在O(n^2)的时间复杂度下完成，但空间复杂度降低到O(1)。两种方法各有优劣，适用于不同的场景。

摘要由CSDN通过智能技术生成

5. 最长回文子串

题目描述

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

示例：

输入：s = "babad"

输出："bab"

解释："aba"同样是符合题意的答案。

解答

动态规划

回文串天生自带状态转移的属性，对于一个回文串来说，去掉两头的字符，剩余部分必定也是一个回文串；同样的，如果一个字符串两端的字符不相等，那么这个字符串必定不是一个回文串。因此考虑动态规划。

令 $d p [i] [j]$ 表示字符串 $s [i : j]$ 是否是一个回文串，那么有如下的状态转移：

$dp[i][j]=dp[i+1][j-1]\qquad if (s[i]==s[j])$
$\qquad if(s[i]!=s[j])$

在上面的状态转移第一种情况中，我们需要考虑下标的合法性：

如果一个子串的长度为2，并且两端的字符相等，那么该子串必定是回文串；

如果一个子串的长度为3，并且两端的字符相等，那么该子串必定是回文串；

综上，当满足条件 $\quad and \quad j-i+1<=3$ 时， $d p [i] [j] = t r u e$

所以，我们得到最终的状态转移方程：

$dp[i][j]=false\qquad if(s[i]\ !=s[j]);$

$dp[i][j]=true\qquad if (s[i]==s[j]\quad and\quad j-i+1<=3);$

$dp[i][j]=dp[i+1][j-1]\qquad if (s[i]==s[j]\quad and\quad j-i+1>3).$

填写 $d p$ 数组的时候我们注意到， $d p [i] [j]$ 可能由左下方的格子 $d p [i + 1] [j - 1]$ 转移而来，因此要保证其左下方的格子先被填好。所以在循环填写的时候按列填写。

针对本题的具体实现中，需要一个全局变量 $m a x L e n$ 记录最长回文串的长度， $b e g i n$ 记录这个最长回文串对应的起始下标，每次填写 $d p$ 数组的时候更新这两个变量。最后再对字符串进行截取，返回 $\ maxLen)$ 即可。

时间复杂度： $O(n^2)$

空间复杂度： $O(n^2)$

class Solution{
public:
	string longestPalindrome(string s) {
        int n = s.size();
        // 特判如果字符串长度小于2，返回它本身
        if (n < 2) {
            return s;
        }
        vector<vector<int>> dp(n, vector<int>(n));
        // dp[i][j]表示字符串从i到j是否是回文串
        // 初始化dp[i][i]为true
        for (int i = 0; i < n; i++) {
            dp[i][i] = 1;
        }
        int maxLen = 1, begin = 0;
        // 按列填写dp数组，保证每个格子的左下方格子都先被填好
        for (int j = 0; j < n; j++) {
            for (int i = 0; i < j; i++) {
                if (s[i] != s[j]) {
                    dp[i][j] = 0;
                } else if (j - i + 1 <= 3) {
                    dp[i][j] = 1;
                } else {
                    dp[i][j] = dp[i + 1][j - 1];
                }
                // 更新maxLen和begin
                if (dp[i][j] && (j - i + 1) > maxLen) {
                    maxLen = j - i + 1;
                    begin = i;
                }
            }
        }
        return s.substr(begin, maxLen);
    }
};

中心扩展法

枚举每个子串的中心位置，向两边扩展，直到不能扩展。

奇数长度的字符串中心为一个字符，偶数长度的字符串中心为两个字符，因此对每一个位置 $i$ ，子串的中心可能为s[i]，也可能为s[i]和 s[i+1] ，分别进行扩展，记录最长的长度和开始下标。

时间复杂度： $O(n^2)$

空间复杂度： $O (1)$

class Solution{
    pair<int, int> expand(string s, int left, int right) {
        while (left >= 0 && right < s.size() && s[left] == s[right]) {
            left--;
            right++;
        }
        // 退出循环时的 left、right 已经不满足回文串
        return {left + 1, right - 1};
    }
public:
    string longestPalindrome(string s) {
        int start = 0, maxLen = 0;
        for (int i = 0; i < s.size(); i++) {
            auto [left1, right1] = expand(s, i, i);
            auto [left2, right2] = expand(s, i, i + 1);
            if (right1 - left1 + 1 > maxLen) {
                start = left1;
                maxLen = right1 - left1 + 1;
            }
            if (right2 - left2 + 1 > maxLen) {
                start = left2;
                maxLen = right2 - left2 + 1;
            }
        }
        return s.substr(start, maxLen);
    }
};