Leecode刷题热题HOT100(5)——最长回文子串

📋 前言

• 🖱 博客主页：在下马农的碎碎念
• 🤗 欢迎关注🔎点赞👍收藏⭐️留言📝
• ✍ 本文由在下马农原创，首发于CSDN
• 📆 首发时间：2021/12/19
• 📅 最近更新时间：2021/12/27
• 🤵 此马非凡马，房星本是星。向前敲瘦骨，犹自带铜声。
• 📇 系列文章目录: 快点我呀，我是目录
• 🙏作者水平有限，如发现错误，请留言轰炸哦！万分感谢！

望着窗外，只要想起一生中后悔的事 ，梅花便落满了南山。——张枣《镜中》

以下是正文

🍅 题目

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

示例 1：

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

示例 2：

输入：s = "cbbd"
输出："bb"

示例 3：

输入：s = "a"
输出："a"

示例 4：

输入：s = "ac"
输出："a"

提示：

• 1 <= s.length <= 1000
• s 仅由数字和英文字母（大写和/或小写）组成

🍅 解题思路

🍏方法一：中心扩展

回文字符串的特点：正着读和反着读是一样的，即字符串是对称的
这样所有的回文字符串都可以分为两种情况：

1. 一个元素为中心的情况。例如aba，n种情况
2. 两个元素为中心的情况。例如abba，n-1种情况
   由中心开始向两侧扩展就可以找到以某元素或某两个元素为中心的回文字符串。

🍅 我的答案

class Solution {
public:
	// 用来求出以某中心扩展得出的最长回文串
	// 返回回文串在字符串中的起始位置和结束位置，用一个pair返回。
    pair<int,int> getPalindromicFromCenter(string &str,int left,int right){
        pair<int,int> p(0,0);
        // 向两边扩展到的两个元素不相等或到达边界时跳出循环
        while(left>=0&&right<str.size()&&str[left] == str[right]){
        	// 当前回文串的左边界和右边界
            p.first = left;
            p.second = right;
           	// 继续向两侧扩展
            left--;
            right++;
        }
        return p;
    }
    string longestPalindrome(string s) {
        pair<int,int> p1(0,0);
        pair<int,int> p2(0,0);
        int left1=0;
        int left2=0;
        int right1=0;
        int right2=0;
		// 长度为1，直接返回
        if(s.size()==1){
            return s;
        } else {
            for(int i = 0;i<s.size()-1;i++){
            	// 遍历每一种单元素为中心和双元素为中心的情况
            	// 求每一种情况的最长回文串的左右边界
                p1 = getPalindromicFromCenter(s,i,i);
                p2 = getPalindromicFromCenter(s,i,i+1);
                // 如果以单元素为中心新求得的回文串长度大于当前回文串长度
                // 更新单元素为中心得出最长回文串的左右边界
                if(p1.second-p1.first>right1-left1) {
                    left1 = p1.first;
                    right1 = p1.second;
                }
                // 如果以双元素为中心新求得的回文串长度大于当前回文串长度
                // 更新双元素为中心得出最长回文串的左右边界
                if(p2.second-p2.first>right2-left2) {
                    left2 = p2.first;
                    right2 = p2.second;
                }
            }
            // 单元素和双元素为中心的回文串，谁的长度长即为最终结果
            if(right1-left1>right2-left2) {
                return s.substr(left1,right1-left1+1);
            } else {
                return s.substr(left2,right2-left2+1);
            }
        }
    }
};

🍅 优质解答

动态规划

#include <iostream>
#include <string>
#include <vector>

using namespace std;

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

        int maxLen = 1;
        int begin = 0;
        // dp[i][j] 表示 s[i..j] 是否是回文串
        vector<vector<int>> dp(n, vector<int>(n));
        // 初始化：所有长度为 1 的子串都是回文串
        for (int i = 0; i < n; i++) {
            dp[i][i] = true;
        }
        // 递推开始
        // 先枚举子串长度
        for (int L = 2; L <= n; L++) {
            // 枚举左边界，左边界的上限设置可以宽松一些
            for (int i = 0; i < n; i++) {
                // 由 L 和 i 可以确定右边界，即 j - i + 1 = L 得
                int j = L + i - 1;
                // 如果右边界越界，就可以退出当前循环
                if (j >= n) {
                    break;
                }

                if (s[i] != s[j]) {
                    dp[i][j] = false;
                } else {
                    if (j - i < 3) {
                        dp[i][j] = true;
                    } else {
                        dp[i][j] = dp[i + 1][j - 1];
                    }
                }

                // 只要 dp[i][L] == true 成立，就表示子串 s[i..L] 是回文，此时记录回文长度和起始位置
                if (dp[i][j] && j - i + 1 > maxLen) {
                    maxLen = j - i + 1;
                    begin = i;
                }
            }
        }
        return s.substr(begin, maxLen);
    }
};

中心扩展

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

    string longestPalindrome(string s) {
        int start = 0, end = 0;
        for (int i = 0; i < s.size(); ++i) {
            auto [left1, right1] = expandAroundCenter(s, i, i);
            auto [left2, right2] = expandAroundCenter(s, i, i + 1);
            if (right1 - left1 > end - start) {
                start = left1;
                end = right1;
            }
            if (right2 - left2 > end - start) {
                start = left2;
                end = right2;
            }
        }
        return s.substr(start, end - start + 1);
    }
};

🍅 知识积累

1. 使用pair可以返回由两个值组成的一对值

pair<int,int> p(0,0);
p.first = 2;
p.second = 3;

---

随手点赞👍一次,运气增加一分哦🙏🙏🙏

---

注：本文中题目信息及优质解答来自力扣网