LeetCode 5. 最长回文子串（动态规划，中心扩散法）

最新推荐文章于 2023-01-08 08:00:00 发布

LikeMarch

最新推荐文章于 2023-01-08 08:00:00 发布

阅读量139

点赞数 1

分类专栏：研究生生活——算法文章标签： leetcode 字符串

本文链接：https://blog.csdn.net/m0_37433111/article/details/108668553

版权

研究生生活——算法专栏收录该内容

105 篇文章 1 订阅

订阅专栏

2020年9月18日周五天气晴【不悲叹过去，不荒废现在，不惧怕未来】

本文目录

1. DP

DP法主要注意两点：

状态的选择：dp[i][j] 表示子串 s[i..j] 是否为回文子串，这里子串 s[i..j] 定义为左闭右闭区间，可以取到 s[i] 和 s[j]。
遍历的方式：外层遍历 j，内层遍历 i，意思为先固定 j，然后移动 i，这样才能保证由长度较短的字符串向长度较长的字符串进行转移。

class Solution {
public:
	string longestPalindrome(string s) {
        int n = s.size();
        if(n<2) return s;

        int beg=0,maxLen=1;
        vector<vector<bool>> dp(n,vector<bool>(n,true)); // 初始时全定义为true
        // 注意：要先固定j，移动i，才能保证由长度较短的字符串向长度较长的字符串进行转移
        for(int j=1;j<n;++j){
            for(int i=0;i<j;++i){
            	// 如果以索引i，j为首尾的字符串满足回文子串的条件
                if(s[i]==s[j] && dp[i+1][j-1]) {
                    dp[i][j]=true;
                    int curLen = j-i+1;
                    if(curLen>maxLen){
                        beg = i;
                        maxLen = curLen;
                    }
                }
                // 不满足回文子串的条件
                else dp[i][j]=false;
            }
        }
        return s.substr(beg,maxLen);
	}
};

时间复杂度： $O\left( {n^2} \right)$
空间复杂度： $O\left( {n^2} \right)$

2. 中心扩散法

这种方法比DP法有更好的空间复杂度，具体思路为：遍历每个字符，由中心向两边扩散，获得最大回文子串长度。需要注意的是，每次遍历需要考虑最长回文子串的长度有奇数和偶数两种可能情况。

class Solution {
public:
	string longestPalindrome(string s) {
        int n = s.size();
        if(n<2) return s;

        int l = 0, r = 0;
        for(int i=0;i<n-1;++i){
            auto idx_odd = helper(s,i,i); // 最长回文奇子串
            auto idx_even = helper(s,i,i+1); // 最长回文偶子串
            // 记录两回文字串中较长那个的首尾索引
            if(idx_odd.second - idx_odd.first > r - l){
                r = idx_odd.second;
                l = idx_odd.first;
            }
            if(idx_even.second - idx_even.first > r - l){
                r = idx_even.second;
                l = idx_even.first;
            }
        }
        return s.substr(l,r-l+1);
	}

    // 返回最长回文子串的首尾索引
    pair<int,int> helper(string s,int l,int r){
        while(l>=0 && r<s.size() && s[l]==s[r]){
            --l;++r;
        }
        // 这里的返回值比较巧妙，考虑到了上面 while 条件中各种情况，仔细体会
        return {l+1,r-1};
    }
};