最长回文子串

最新推荐文章于 2025-07-25 16:23:30 发布
原创 最新推荐文章于 2025-07-25 16:23:30 发布 · 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 898
通过这道题，我们学习了最长回文子串的三种解法，分别为：暴力求解法、动态规划法和中心扩展算法。实际上，还有一种效率更高的Manacher算法，其时间复杂度为O(n)。大家可以自行去了解，这里就不再赘述了。
蓝桥杯1225——最长回文子串（python）
Gyy1314521的博客
02-03 1165
使用暴力求解法、中心扩展法、Manacher算法解决最长回文子串问题
最长回文子串-leetCode-005
m0_74287204的博客
05-09 859
回文子串：暴力法，中心拓展法，动态规划，Manacher 算法
动态规划 最长回文子串
红血哥
06-25 649
本文介绍了寻找字符串中最长回文子串的两种算法：动态规划法和中心扩展法。动态规划通过构建二维数组记录子串状态，时间复杂度O(n²)，空间复杂度O(n²)；中心扩展法从所有可能的中心点向两边扩展，时间复杂度O(n²)，空间复杂度O(1)。两种方法都能有效解决问题，中心扩展法在空间上更优。文章详细阐述了算法思路、代码实现和测试用例，并以"babad"和"cbbd"为例演示了求解过程。
5. 最长回文子串
所有专家都曾始于新手
10-17 1193
回文是指正着读和反着读都一样的字符串。例如，"aba"和"racecar"都是回文。中心扩展法通过将每个字符（或字符之间的间隙）作为回文的中心，从中向外扩展来寻找最长的回文子串。它是一种直观、易于实现的算法，在时间复杂度为 (O(n^2)) 的情况下，可以高效解决回文子串问题。Lambda 函数是 C++ 中的一个非常强大的工具，用于简化代码。在你的代码中，是一个典型的使用案例，简化了回文扩展的实现，并捕获了外部变量来动态调整回文子串的起始位置和长度。
Leetcode 最长回文子串
freeRoad
11-20 1009
题目：给你一个字符串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 2034
文中主要讲述Manacher算法求解最长回文子串问题，包括Manacher算法基本思想、manacher算法对称性中的计算、manacher算法代码实现、最长回文子串长度及所有的最长回文子串和个数(数量)。
【算法入门】5. 最长回文子串 LeetCode 5：最长回文子串 - 动态规划与中心扩展法详解（Java & JavaScript）（Java/JS实现）
南北极之间
05-27 1025
本文介绍了如何解决最长回文子串问题，重点讲解了中心扩展法的实现。该方法通过以每个字符或字符间隙为中心向两边扩展，检测最长回文子串。文章提供了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"，...
枚举右，维护左基础篇
m0_68367618的博客
07-23 363
本文总结了力扣题单中基于双变量问题的通用解法模板。核心思路是：通过维护已遍历区间（使用哈希表、集合或滑动窗口），枚举未遍历区间来优化双变量问题。
php算法-- 关联数组使用，优化sip账号去重
最新发布
qq_43538607的博客
07-25 218
php-关联数组使用，优化sip账号去重
力扣-416.分割等和子集
weixin_46878941的博客
07-25 144
小结：01背包问题，先遍历物品，再遍历背包，逆序遍历背包，确保每个数组只用一次。
力扣-300.最长递增子序列
weixin_46878941的博客
07-22 572
小结：注意最长递增子序列可能不包含最后一个值，所以要用一个变量记录。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值