最长回文子串(力扣)

https://leetcode.cn/problems/longest-palindromic-substring/description/

(先叠个甲,我是初学者)

由这个题可以看出,初步的动态规划就是递归加记忆化。

如何判断回文:

在做这个题之前,已经接触过回文题目,当时的做法是双指针(感觉挺高大上的),是用两个变量记作位置,从两端开始判断是否相等

这个思路似乎没法列出动态规划的状态转移的那个方程(我没想出来),官方题解给出的思路(咱是初学者看题解不丢人,只要能自己再从0到1敲出来,就没关系)大致思路也是这样,但是处理的方法比较巧妙吧(算是),就是像剥洋葱一样,逐层判断。

状态转移方程:P(i,j)=P(i+1,j−1)∧(Si​==Sj​)

​
​
#include <iostream>
#include <string>
#include <vector>
class Solution {
public:
    string longestPalindrome(string s) {
        int len = s.length();
        if (len == 1) {
            return s;
        }
        vector<vector<int>> dp(len, vector<int>(len));
        for (int i = 0; i < len; i++)
            dp[i][i] = 1; // 长度为1的是回文串
        int z = 0, y = 1;
        for (int l = 2; l <= len; l++) { // 字串的长度
            for (int i = 0; i < len; i++) {
                int j =
                    l + i -
                    1; // 减少时间复杂度,经典的是鸡兔同笼,通过数学计算减少循环层数
                if (j >= len)
                    break;
                if (s[i] != s[j])
                    dp[i][j] = 0; // 状态转移方程
                else {
                    if (j - i <= 2) // 长度为2的两两相等为回文串,为3确保两头相等
                        dp[i][j] = 1;
                    else
                        dp[i][j] = dp[i + 1][j - 1]; // dp的赋值从小到大进行
                }
                if (dp[i][j] == 1 && l > y) { // 遇到长度更长会迭代
                    y = l;
                    z = i;
                }
            }
        }
        return s.substr(z, y);
    }
};

​

​

### 暴力解法 暴力解法是最容易想到的方法,其核心思想是截取字符串的所有子串,然后逐一判断这些子串是否为回文,并记录最长回文子串。这种方法虽然直观,但效率较低,时间复杂度为 $O(n^3)$,因为需要遍历所有可能的子串($O(n^2)$),并对每个子串进行回文检查($O(n)$)。 以下是使用暴力解法的Python实现: ```python class Solution: def longestPalindrome(self, s: str) -> str: if len(s) < 2: return s start = 0 # 记录最长回文子串开始的位置 max_len = 0 # 记录最长回文子串的长度 for i in range(len(s) - 1): for j in range(i, len(s)): if j - i < max_len: continue if self.is_palindrome(s, i, j): max_len = j - i + 1 start = i return s[start:start + max_len] def is_palindrome(self, s: str, left: int, right: int) -> bool: while left < right: if s[left] != s[right]: return False left += 1 right -= 1 return True ``` ### 动态规划方法 动态规划是一种更高效的解决方案,它通过存储中间结果来避免重复计算。定义一个二维数组 `dp` 来表示子串是否为回文。如果 `s[i:j+1]` 是回文,则 `dp[i][j] = True`;否则为 `False`。状态转移方程如下: - 如果 `s[i] == s[j]` 且 `i+1 > j-1`(即子串长度小于等于3),则 `dp[i][j] = True`。 - 如果 `s[i] == s[j]` 且 `dp[i+1][j-1]` 为 `True`,则 `dp[i][j] = True`。 下面是基于动态规划的Python实现: ```python class Solution: def longestPalindrome(self, s: str) -> str: n = len(s) if n < 2: return s dp = [[False] * n for _ in range(n)] max_len = 1 start = 0 for j in range(n): for i in range(j + 1): if i == j: dp[i][j] = True elif s[i] == s[j]: if j - i <= 2: dp[i][j] = True else: dp[i][j] = dp[i + 1][j - 1] if dp[i][j] and j - i + 1 > max_len: max_len = j - i + 1 start = i return s[start:start + max_len] ``` ### 中心扩展法 中心扩展法利用了回文串的对称性,通过枚举每一个可能的中心点并尝试向两边扩展,找到最长回文子串。由于回文可以是奇数长度或偶数长度,因此需要考虑两种情况:以单个字符为中心(奇数长度)和以两个字符为中心(偶数长度)。 以下是使用中心扩展法的Python实现: ```python class Solution: def longestPalindrome(self, s: str) -> str: if len(s) < 2: return s start = 0 max_len = 0 def expand(left: int, right: int) -> tuple: while left >= 0 and right < len(s) and s[left] == s[right]: left -= 1 right += 1 return (left + 1, right - 1) for i in range(len(s)): l1, r1 = expand(i, i) l2, r2 = expand(i, i + 1) if r1 - l1 > max_len: start, max_len = l1, r1 - l1 if r2 - l2 > max_len: start, max_len = l2, r2 - l2 return s[start:start + max_len + 1] ``` ### 总结 - **暴力解法** 简单直接,但效率较低,适合理解问题的基本思路。 - **动态规划** 通过存储中间结果优化了性能,适用于较长的字符串。 - **中心扩展法** 利用了回文串的特性,仅需线性空间,时间和空间效率都较好。 每种方法都有其优缺点,在实际应用中可以根据具体需求选择合适的算法。对于LeetCode上的测试用例,这三种方法都可以正确解决问题,但在处理大数据集时,动态规划和中心扩展法更为高效[^1]。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值