最长回文子串(力扣(LeetCode)-5)

本文介绍了一种使用动态规划解决LeetCode上寻找最长回文子串问题的方法。通过构建二维数组来记录字符串中各子串是否为回文,从而找到最长的回文子串。算法的时间复杂度为O(N^2),适用于最大长度为1000的字符串。

给定一个字符串 s,找到 s 中最长的回文子串。你可以假设 s 的最大长度为 1000。

示例 1:

输入: "babad"
输出: "bab"
注意: "aba" 也是一个有效答案。
示例 2:

输入: "cbbd"
输出: "bb"

来源:力扣(LeetCode)
链接:https://leetcode-cn.com/problems/longest-palindromic-substring

方法一:

动态规划

设状态dp[j][i]表示索引j到索引i的子串是否是回文串。则转移方程为:

 

则dp[j][i]为true时表示索引j到索引i形成的子串为回文子串,且子串起点索引为j,长度为i - j + 1。
算法时间复杂度为O(N ^ 2)。


 

class Solution {
    public String longestPalindrome(String s) {
        int length=s.length();
        int[][] array=new int[length][length];
        int max=1;
        int start=0;
        if(s.equals(""))
            return "";
        if(length==1)
            return s;
        for(int j=0;j<length;j++){
            for(int m=0;m<=j;m++){
                if(j-m<2){
                    if(s.charAt(j)==s.charAt(m)){
                        array[m][j]=1;
                    }
                }else{
                    if(s.charAt(j)==s.charAt(m)){
                        array[m][j]=array[m+1][j-1];
                    }
                }
                if((array[m][j]==1)&&(max<=j-m+1)){
                    start=m;
                    max=j-m+1;
                }
            }
        }
        return s.substring(start,start+max);
    }
      
}

 

### 暴力解法 暴力解法是最容易想到的方法,其核心思想是截取字符串的所有子串,然后逐一判断这些子串是否为回文,并记录最长回文子串。这种方法虽然直观,但效率较低,时间复杂度为 $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、付费专栏及课程。

余额充值