5. 最长回文子串

贤哥不闲

已于 2023-07-26 14:38:26 修改

阅读量23

点赞数

文章标签：算法 leetcode 动态规划 c++

于 2023-07-26 12:28:19 首次发布

本文链接：https://blog.csdn.net/weixin_45564749/article/details/131932115

版权

痛苦的一题，呜呜呜

题目描述

给你一个字符串 s，找到 s 中最长的回文子串。如果字符串的反序与原始字符串相同，则该字符串称为回文字符串。

示例 1：

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

思路历程

一开始想的是获取子串，逐个判断是否为回文字符串，结果超出了时间限制。

优化1：中心扩展法

优化2：动态规划法

代码实现

代码1

class Solution {
public:
    string longestPalindrome(string s) {
        if (s.length() == 1) {//单个字符则直接返回
            return s;
        }
        int length = 0;
        string longstr = "";
        for (int i = 0; i < s.size(); ++i) {
            for (int j = i + 1; j <= s.size(); ++j) {//遍历每个子串
                //如果是回文子串且长度更长则更新
                if (ishuiwen(s.substr(i, j - i)) && length < j - i + 1) {
                    length = j - i + 1;
                    longstr = s.substr(i, j - i);
                }
            }
        }
        return longstr;
    }
    
    bool ishuiwen(string substr) {//判断是否为回文字符串
        int i = 0;
        int j = substr.size() - 1;
        for (; i < j; ++i, --j) {//从两边到中间移动
            if (substr[i] != substr[j]) {
                return false;
            }
        }
        return true;
    }
};

代码2

中心扩展法（优化时间复杂度）：遍历字符串的每个字符，将其作为回文字符串的中心，然后向两侧扩展比较字符是否相等，直到不满足条件为止。这种方法利用了回文字符串的对称特性，可以将时间复杂度降低到O(n^2)。

class Solution {
public:
    string longestPalindrome(string s) {
        int start = 0, end = 0;
        
        for (int i = 0; i < s.length(); i++) {
            int len1 = expandAroundCenter(s, i, i); // 回文字符串长度为奇数的情况,返回奇数回文子串的长度
            int len2 = expandAroundCenter(s, i, i + 1); // 回文字符串长度为偶数的情况，返回偶数回文子串的长度
            int len = max(len1, len2);
            
            if (len > end - start) {//更新最长回文子串的起始和结束位置
                start = i - (len - 1) / 2;
                end = i + len / 2;
            }
        }
        
        return s.substr(start, end - start + 1);
    }
    //获得以s为中心的回文子串的长度
    int expandAroundCenter(string s, int left, int right) {
        while (left >= 0 && right < s.length() && s[left] == s[right]) {
            left--;
            right++;
        }
        
        return right - left - 1;
    }
};

代码3

动态规划（优化空间复杂度）：使用动态规划来解决回文字符串问题，通过记录子问题的结果来避免重复计算。定义一个二维数组dp[i][j]，表示从索引i到j的子串是否为回文字符串。初始状态为dp[i][i] = true（单个字符为回文字符串），然后逐渐扩展子串的长度，通过状态转移方程dp[i][j] = (s[i] == s[j]) && dp[i+1][j-1]来更新数组。最后，找出最长的回文子串即可。这种方法的时间复杂度为O(n^2)，空间复杂度为O(n^2)。

class Solution {
public:
    string longestPalindrome(string s) {
        int n = s.length();
        // 动态规划数组，dp[i][j] 表示 s[i...j] 是否为回文子串
        vector<vector<bool>> dp(n, vector<bool>(n, false));  
        int start = 0, end = 0, maxLength = 0;  // 记录最长回文子串的起始位置和长度
    
        for (int i = n - 1; i >= 0; i--) {  // 从后往前遍历字符串
            for (int j = i; j < n; j++) {  // 从当前位置向后遍历字符串
                // 如果字符相等且子串 s[i+1...j-1] 是回文串
                if (s[i] == s[j] && (j - i <= 2 || dp[i + 1][j - 1])) {  
                    dp[i][j] = true;  // 将当前子串标记为回文串
                    int length = j - i + 1;  // 当前回文子串的长度
                    if (length > maxLength) {  // 如果当前回文子串的长度大于之前记录的最长长度
                        maxLength = length;  // 更新最长回文子串的长度
                        start = i;  // 更新最长回文子串的起始位置
                        end = j;  // 更新最长回文子串的结束位置
                    }
                }
            }
        }
    
        return s.substr(start, maxLength);  // 返回最长回文子串
    }
};