最长回文子串

最新推荐文章于 2025-07-23 22:59:22 发布
原创 最新推荐文章于 2025-07-23 22:59:22 发布 · 1.6k 阅读 · 29 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#算法

*************

C++

题目：5. 最长回文子串 - 力扣（LeetCode）

*************

看一眼题目：

这个题目跟之前有点不太一样，这个我不会用矩阵了。难度有所上升了，变得有些棘手了。

突然想到 char 和 int 为什么需要相互转换。本质上来说，char 和 int 都是需要开辟一点空间用来存储，命名不一样而已。char 只有1字节，而int可以是2个字节。翻译成机器语言就是：

char: 00 00 00 00;

int:    00 00 00 00 00 00 00 00;

本质上来说，都是让计算机开辟出一个空间用于存储数据，这个就相当于快捷指令，char：给我一间房，安排上8个座位； int：我这个包间需要的大一点，给我一间房，安排上16个座位。

扯远了，现在回到题目上。这个起手就是 get 一下 string 的长度 n，然后构建一个简单的矩阵，起手的矩阵是 dp[0][j]，这是一个只有一行的矩阵，为了保持统一，我喜欢使用m & i 用于描述行， n & j 用于描述列，个人习惯，S & M 用于描述行也行，人要是行，干一行，行一行。一行行，行行行；要是不行，干一行，不行一行。一行不行，行行不行‌13。

如果字符串是空的，返回空字符串。如果字符串只有一个元素，那么就是他本身。这两个情况的代码很好写。优化一下这两个情况就是，如果s只有0个或者1个元素，子串就是s本身。

class Solution {
public:
    string longestPalindrome(string s) {
        if (s.empty()) return "";

想到一个解决方案就是，遍历整个s，从第 i 个字母开始判断，如果第 i - 1 = i + 1个字母相等，那么就是回文,指针滑到i - 2 =? i + 2, 如果是，那么判断i - 3 =? i + 3，以此类推。这是一个很天才的想法，后来看到别人的解答才知道这个思路是中心扩展法。这里有一个语法center(s, m, m),注意，这里的m是同一个元素，意思是回文子串是s，回文子串的起点是m，终点也是m，这里对应的是奇数回文子串，1个s只有1个m。对应偶数的话就是center(s, m, m + 1)，这里的1个s有两个m，字符串的起点是m，重点是m + 1。

举例，

sabcdcbas
i01234567

s =  a b c d c b a s ，这是一个even number，为什么even是偶数的意思呢，可能是因为even还有其他的意思，为平等的，不倾斜的。假设center（s, d, d）,那么就是s的起点是d，终点也是d。然后比较2号位和4号位，以此类推。

接下来的我看的不是很懂，就直抄过来吧，以下是完整的代码。

class Solution {
public:
    string longestPalindrome(string s) {
        if (s.empty()) return "";
        
        int start = 0, end = 0; // to store the sting's start and end

        for (int i = 0; i < s.size(); i++){
            int len1 = expandAroundCenter(s, i, i); // for odd numbers
            int len2 = expandAroundCenter(s, i, i + 1); // for even numbers
            int length = max(len1, len2);

            if (length > end - start){
                start = i - (length - 1) / 2; //fresh the start
                end = i + length / 2; // note that / means round down
            }
        }
        return s.substr(start, end - start + 1);

    private:
        int expandAroundCenter(const string& s, int left, int right) {
        while (left >= 0 && right < s.size() && s[left] == s[right]) {
            --left;
            ++right;
        }
        return right - left - 1; 
    }
};

但是，话说回来，我还是喜欢矩阵，不使用矩阵的话总感觉缺点什么。

矩阵 s = b a b a d; 

s[0] = b, s[1] = a 

矩阵 dp[i][i] 代表什么？就是坐标，dp[1][3]表示字符串第一位和第三位。

请上我的老朋友，矩阵，为了方便我理解。

dp01234
sbabad
0bT
1aT
2bT
3aT
4bT

单个字母总是回文，因为就是它本身，所以初始化都是T。

  • 检查 s[0] 和 s[1] 是否相等，即 b == a，不相等，所以 dp[0][1] 为 false。
  • 检查 s[1] 和 s[2] 是否相等，即 a == b，不相等，所以 dp[1][2] 为 false。
  • 检查 s[2] 和 s[3] 是否相等，即 b == a，不相等，所以 dp[2][3] 为 false。
  • 检查 s[3] 和 s[4] 是否相等，即 a == d，不相等，所以 dp[3][4] 为 false。

然后依次填充：

dp01234
sbabad
0bTFTFF
1aFTFTF
2bTFTFF
3aFTFTF
4bTFTFT

矩阵的起手式已经很熟练了，直接可以写得出来：

class Solution {
public:
    string longestPalindrome(string s) {

       int n = s.size(); // get the length of the string
       vector<vector<bool>> dp(n, vector<bool>(n, false)); // initialise the array
       string longest = "";  // initialise the longest string
    }
};

考虑到如果矩阵只有1个元素或者是空的话，就直接返回他本身就可以了，到这一步也是比较的简单，可以直接写出来。

class Solution {
public:
    string longestPalindrome(string s) {

       int n = s.size(); // get the length of the string
       vector<vector<bool>> dp(n, vector<bool>(n, false)); // initialise the array
       string longest = "";  // initialise the longest string

       //int n = s.size();
       if (n < 2) return s;
    }
};

很好理解了，单个字母的回文就是他本身。

class Solution {
public:
    string longestPalindrome(string s) {

       int n = s.size(); // get the length of the string
       vector<vector<bool>> dp(n, vector<bool>(n, false)); // initialise the array
       string longest = "";  // initialise the longest string

       //int n = s.size();
       if (n < 2) return s;

       // all the single is good
       for (int i = 0; i < n; i++){
        dp[i][i] = true;
        longest = s[i];
       }

检查两个相邻的字母是否能够组成回文呢？

  • 检查 s[0] 和 s[1] 是否相等，即 b == a，不相等，所以 dp[0][1] 为 false。
  • 检查 s[1] 和 s[2] 是否相等，即 a == b，不相等，所以 dp[1][2] 为 false。
  • 检查 s[2] 和 s[3] 是否相等，即 b == a，不相等，所以 dp[2][3] 为 false。
  • 检查 s[3] 和 s[4] 是否相等，即 a == d，不相等，所以 dp[3][4] 为 false。

回顾上面的array，就更加的好理解了，加上一点语法

class Solution {
public:
    string longestPalindrome(string s) {

       int n = s.size(); // get the length of the string
       vector<vector<bool>> dp(n, vector<bool>(n, false)); // initialise the array
       string longest = "";  // initialise the longest string

       //int n = s.size();
       if (n < 2) return s;

       // all the single is good
       for (int i = 0; i < n; i++){
        dp[i][i] = true;
        longest = s[i];
       }

       // check that if two in a row are same
       for (int i = 0; i < n - 1; i++){
           if (dp[i][i + 1] = true){
            longest = s.substr(i, 2);
           }
       }
    }
};

难度继续提升，如果回文长度＞2，至少3个字母呢？首先得是首尾元素相同。

  • 从长度为3的子串开始检查。对于子串 s[0]s[1]s[2]（"bab"），首尾字符相同（b == b），且 dp[1][1] 为 true（因为单个字符是回文），所以 dp[0][2] 为 true。
  • 对于子串 s[1]s[2]s[3]（"aba"），首尾字符相同（a == a），且 dp[2][2] 为 true，所以 dp[1][3] 为 true。
  • 对于子串 s[2]s[3]s[4]（"bad"），首尾字符不同（b != d），所以 dp[2][4] 为 false。

4个字母就是：

  • 对于子串 s[0]s[1]s[2]s[3]（"baba"），首尾字符相同（b == a），且 dp[1][2] 为 false，所以 dp[0][3] 为 false。
  • 对于子串 s[1]s[2]s[3]s[4]（"abad"），首尾字符相同（a == d），且 dp[2][3] 为 false，所以 dp[1][4] 为 false。

所以递归一下，就是，先要首尾元素相同，如果是，那就检查去掉首尾字母之后的串的首尾字母是否相同，如果是，继续套娃。

就是先假设回文有3个字母的：

knock knock. who's that?             s[0]s[1]s[2]这三个是不是回文啊？

knock knock. who's that?             s[1]s[2]s[3]这三个是不是回文啊？

knock knock. who's that?             s[n  - 2]s[n - 1]s[n]这三个是不是回文啊？

3个字母的问完了就去问四个字母的：

knock knock. who's that?             s[0]s[1]s[2]s[3]这三个是不是回文啊？

以此类推

class Solution {
public:
    string longestPalindrome(string s) {

       int n = s.size(); // get the length of the string
       vector<vector<bool>> dp(n, vector<bool>(n, false)); // initialise the array
       string longest = "";  // initialise the longest string

       //int n = s.size();
       if (n < 2) return s;

       // all the single is good
       for (int i = 0; i < n; i++){
        dp[i][i] = true;
        longest = s[i];
       }

       // check that if two in a row are same
       for (int i = 0; i < n - 1; i++){
           if (s[i] == s[i + 1]){
            dp[i][i + 1] = true;
            longest = s.substr(i, 2);
           }
       }

        for (int len = 3; len <= n; len++) {
            for (int i = 0; i < n - len + 1; i++) {
                int j = i + len - 1;
                if (s[i] == s[j] && dp[i + 1][j - 1]) {
                    dp[i][j] = true;
                    longest = s.substr(i, len);
                }
            }
        }
        
        return longest;
    }
};

今天还顺便多学了一个语法，就是在 C++ 中，s.substr(i, len) 是一个字符串成员函数，它用于从字符串 s 中提取一个子串。这个子串从索引 i 开始，长度为 len。

函数 substr 会返回一个新的字符串，这个字符串包含了从索引 i 开始的 len 个字符。

示例

假设我们有一个字符串 s = "Hello, World!"：

string s = "Hello, World!";
string sub = s.substr(7, 5); // 从索引 7 开始，长度为 5

在这个例子中，sub 的值将会是 "World"，因为从索引 7（包括索引 7）开始的 5 个字符是 "World"。

今天的学习到此为止，可能明天我还依然喜欢矩阵吧，这玩意真的好使。

C++面试宝典第15题：最长回文子串
hope_wisdom的技术博客
01-08 897
通过这道题，我们学习了最长回文子串的三种解法，分别为：暴力求解法、动态规划法和中心扩展算法。实际上，还有一种效率更高的Manacher算法，其时间复杂度为O(n)。大家可以自行去了解，这里就不再赘述了。
蓝桥杯1225——最长回文子串（python）
Gyy1314521的博客
02-03 1160
使用暴力求解法、中心扩展法、Manacher算法解决最长回文子串问题
最长回文子串-leetCode-005
m0_74287204的博客
05-09 856
回文子串：暴力法，中心拓展法，动态规划，Manacher 算法
动态规划 最长回文子串
红血哥
06-25 646
本文介绍了寻找字符串中最长回文子串的两种算法：动态规划法和中心扩展法。动态规划通过构建二维数组记录子串状态，时间复杂度O(n²)，空间复杂度O(n²)；中心扩展法从所有可能的中心点向两边扩展，时间复杂度O(n²)，空间复杂度O(1)。两种方法都能有效解决问题，中心扩展法在空间上更优。文章详细阐述了算法思路、代码实现和测试用例，并以"babad"和"cbbd"为例演示了求解过程。
5. 最长回文子串
所有专家都曾始于新手
10-17 1189
回文是指正着读和反着读都一样的字符串。例如，"aba"和"racecar"都是回文。中心扩展法通过将每个字符（或字符之间的间隙）作为回文的中心，从中向外扩展来寻找最长的回文子串。它是一种直观、易于实现的算法，在时间复杂度为 (O(n^2)) 的情况下，可以高效解决回文子串问题。Lambda 函数是 C++ 中的一个非常强大的工具，用于简化代码。在你的代码中，是一个典型的使用案例，简化了回文扩展的实现，并捕获了外部变量来动态调整回文子串的起始位置和长度。
Leetcode 最长回文子串
freeRoad
11-20 1008
题目：给你一个字符串s，找到s中最长的回文子串。"bab""aba" 同样是符合题意的答案。
LeetCode - 5 最长回文子串
优快云
08-29 727
基于最简回文子串，我们向其两端扩展，比如最简回文子串的范围是 s[i]，那么可以定义 L = i , R = i，只要 s[L] == s[R]，则回文子串扩展成功，新的回文子串范围是 s[L, R]，然后按此逻辑继续扩展 L--，R++，直到发现 s[L]!同理，比如最简回文子串时 s[i, i+1]，那么可以定义 L = i ，R = i + 1，只要 s[L] == s[R]，则回文子串扩展成功，新的回文子串范围是 s[L, R]，然后按此逻辑继续扩展 L--，R++，直到发现 s[L]!
最长回文子串------Manacher算法
Python基础详解教程，让编程变得简单！
02-22 2030
文中主要讲述Manacher算法求解最长回文子串问题，包括Manacher算法基本思想、manacher算法对称性中的计算、manacher算法代码实现、最长回文子串长度及所有的最长回文子串和个数(数量)。
【算法入门】5. 最长回文子串 LeetCode 5：最长回文子串 - 动态规划与中心扩展法详解（Java & JavaScript）（Java/JS实现）
南北极之间
05-27 1014
本文介绍了如何解决最长回文子串问题，重点讲解了中心扩展法的实现。该方法通过以每个字符或字符间隙为中心向两边扩展，检测最长回文子串。文章提供了Java和JavaScript两种语言的详细实现代码，分析了算法的时间复杂度为O(n²)，空间复杂度为O(1)。该方法简洁高效，是解决此问题的经典思路，适合面试和日常算法练习。
python实现求最长回文子串长度
09-20
在Python编程中，解决“最长回文子串”问题是一个经典的字符串处理问题。回文串是指正读和反读都一样的字符串，例如“madam”和“level”。本篇文章将详细探讨如何用Python高效地找到给定字符串的最长回文子串的长度...
LeetCode5. 最长回文子串（双指针、中心扩展算法）
12-20
在LeetCode的第5题《最长回文子串》中，目标是找到给定字符串` s `中的最长回文子串。回文串是指正读反读都能读通的字符串，例如 "aba" 和 "abba" 都是回文串。本题要求的解决方案需在字符串长度不超过1000的限制内...
leetcode答案-Longest-Palindromic-Substring:最长回文子串
06-30
Longest-Palindromic-Substring(最长回文子串) 给定一个字符串 s，找到 s 中最长的回文子串。你可以假设 s 的最大长度为 1000。 Sample 1 输入: "babad" 输出: "bab" 注意: "aba" 也是一个有效答案。 Sample 2 输入...
leetcode-5.最长回文子串
12-21
最长回文子串"是其中一道经典的字符串处理问题，目标是从给定的字符串中找出最长的回文子串。回文串是指正读反读都能读通的字符串，例如 "abcba" 和 "abccba"。 这道题目给出了一些示例，例如输入字符串 "babad"，...
代码随想录算法训练营第二十九天
最新发布
2403_87481241的博客
07-23 553
问题描述：假设有打乱顺序的一群人站成一个队列，数组 people 表示队列中的一些人的属性（每个 people [i] = [h, k] 表示第 i 个人的身高为 h，前面正好有 k 个身高大于或等于 h 的人）。如果存在，返回该起点的索引；这个算法的时间复杂度是 O (n)，空间复杂度是 O (1)，非常高效。这个算法的时间复杂度是 O (n²)（排序 O (nlogn) + 插入操作 O (n²)），空间复杂度是 O (n)。这个算法的时间复杂度是 O (n)，空间复杂度是 O (n)。
飞算JavaAI：基于算法的测评，飞算AI 初学者入门级实测体验
2302_81805546的博客
07-21 648
“别怕算法，它比你想象的要友好得多。只要你愿意动手写代码，飞算AI会陪你一起进步。”
枚举右，维护左
m0_68367618的博客
07-23 257
本文总结了力扣题单中基于双变量问题的通用解法模板。核心思路是：通过维护已遍历区间（使用哈希表、集合或滑动窗口），枚举未遍历区间来优化双变量问题。
OpenCV特征点提取算法orb、surf、sift对比
qq_36812406的博客
07-19 1032
特征对比ORB（推荐实时）SIFT（推荐精度）SURF（研究可选）开源许可✅ 免费✅ 免费❌ 专利受限描述子类型二进制浮点浮点匹配方式汉明距离欧氏距离欧氏距离稳定性中等非常好非常好速度很快慢中等。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值