Leetcode 5 最长回文子串

最新推荐文章于 2024-04-09 18:33:09 发布

原创最新推荐文章于 2024-04-09 18:33:09 发布 · 88 阅读

0 ·

CC 4.0 BY-SA版权

Leetcode 专栏收录该内容

7 篇文章

订阅专栏

本文介绍了两种解决寻找字符串中最长回文子串的方法。第一种是暴力解法，虽然直观但效率较低；第二种是Manacher算法，能够通过巧妙地利用回文性质提高时间复杂度，从而在LeetCode上顺利通过。Manacher算法的关键在于利用已知回文子串的信息，减少不必要的重复计算。

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

示例 1：

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

解1 暴力解法，力扣上会超时，但是好理解

class Solution {
public:
    string longestPalindrome(string s) {
        string res="";  //存放结果
        string temp="";  //存放子串
        for(int i=0;i<s.size();i++){
            for(int j=i;j<s.size();j++){
                temp=temp+s[j];
                string retemp=temp;//retemp存放子串反转结果
                std::reverse(retemp.begin(),retemp.end());//反转
                if(temp==retemp){
                    res=res.length()>temp.length()?res:temp;
                }
               
            }
            temp="";
        }
        return res;
    }
};

解2 可以顺利通过力扣，大佬的算法

class Solution {
public:
    string longestPalindrome(string s) {
        int size = s.size();
        if (size < 2) {
            return s;
        }
        string str = "#";
        for (int i = 0; i < s.size(); i++) {
            str += s[i];
            str += "#";
        }
        // 新字符串的长度
        int strSize = 2 * size + 1;
        // 数组 p 记录了扫描过的回文子串的信息
        vector<int> p(strSize, 0);

        // 双指针，它们是一一对应的，须同时更新
        int maxRight = 0;
        int center = 0;

        // 当前遍历的中心最大扩散步数，其值等于原始字符串的最长回文子串的长度
        int maxLen = 1;
        // 原始字符串的最长回文子串的起始位置，与 maxLen 必须同时更新
        int start = 0;

        for (int i = 0; i < strSize; i++) {
            if (i < maxRight) {
                int mirror = (2 * center) - i;
                // 这一行代码是 Manacher 算法的关键所在，要结合图形来理解
                p[i] = min(maxRight - i, p[mirror]);
            }

            // 下一次尝试扩散的左右起点，能扩散的步数直接加到 p[i] 中
            int left = i - (1 + p[i]);
            int right = i + (1 + p[i]);

            // left >= 0 && right < sLen 保证不越界
            // str.charAt(left) == str.charAt(right) 表示可以扩散 1 次
            while (left >= 0 && right < strSize && str[left] == str[right]) {
                p[i]++;
                left--;
                right++;

            }

            if (i + p[i] > maxRight) {
                // maxRight 和 center 需要同时更新
                maxRight = i + p[i];
                center = i;
            }
            if (p[i] > maxLen) {
                // 记录最长回文子串的长度和相应它在原始字符串中的起点
                maxLen = p[i];
                start = (i - maxLen) / 2;
            }
        }
        return s.substr(start, maxLen);

    }
};