LeetCode-热题100：5. 最长回文子串

题目描述

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

如果字符串的反序与原始字符串相同，则该字符串称为回文字符串。

示例 1：

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

示例 2：

输入： s = “cbbd”
输出： “bb”

提示：

• 1 <= s.length <= 1000
• s 仅由数字和英文字母组成

代码及注释

func longestPalindrome(s string) string {
    n := len(s)
    // 创建一个二维数组 dp，其中 dp[i][j] 表示从字符串的第 i 个字符到第 j 个字符是否为回文串
    dp := make([][]bool, n)
    for i := range dp {
        dp[i] = make([]bool, n)
    }

    res := ""
    // l 表示回文串的长度，从 0 开始逐渐增加
    for l := 0; l < n; l++ {
        // i 表示子串的起始位置
        for i := 0; i < n-l; i++ {
            j := i + l // j 表示子串的结束位置
            if l == 0 {
                // 子串长度为 1 时，一定是回文串
                dp[i][j] = true
            } else if l == 1 {
                // 子串长度为 2 时，判断两个字符是否相等
                dp[i][j] = s[i] == s[j]
            } else {
                // 子串长度大于 2 时，判断首尾字符是否相等，并检查去掉首尾字符后的子串是否为回文串
                dp[i][j] = s[i] == s[j] && dp[i+1][j-1]
            }
            // 如果当前子串是回文串并且长度大于当前最长回文串的长度，则更新最长回文串
            if dp[i][j] && l+1 > len(res) {
                res = s[i : j+1]
            }
        }
    }
    return res
}

代码解释

这里使用动态规划的方法来解决最长回文子串的问题，是因为这个问题具有重叠子问题和最优子结构的特点。

1. 重叠子问题:

   • 在寻找最长回文子串的过程中，我们可能需要多次判断子串是否为回文。例如，为了判断 dp[i][j] 是否为回文，我们可能需要先判断 dp[i+1][j-1] 是否为回文。
   • 动态规划通过存储中间结果，避免了重复计算，提高了效率。

2. 最优子结构:

   • 如果一个字符串的首尾字符相等，并且去掉首尾字符后的子串也是回文，那么整个字符串就是回文。
   • 这种“问题的最优解包含子问题的最优解”特性使得动态规划是解决这个问题的合适方法。

代码解释：

1. 初始化二维数组:

   n := len(s)
   dp := make([][]bool, n)
   for i := range dp {
       dp[i] = make([]bool, n)
   }
   

   • 创建一个二维数组 dp，其中 dp[i][j] 表示从字符串的第 i 个字符到第 j 个字符是否为回文串。

2. 动态规划计算最长回文子串:

   for l := 0; l < n; l++ {
       for i := 0; i < n-l; i++ {
           j := i + l
           if l == 0 {
               dp[i][j] = true
           } else if l == 1 {
               dp[i][j] = s[i] == s[j]
           } else {
               dp[i][j] = s[i] == s[j] && dp[i+1][j-1]
           }
           if dp[i][j] && l+1 > len(res) {
               res = s[i : j+1]
           }
       }
   }
   

   • 动态规划计算最长回文子串的长度。
   • l 表示当前计算的子串长度，从 0 开始逐渐增加。
   • i 表示当前子串的起始位置，j 表示当前子串的结束位置。
   • 对于每个 i 和 j，我们判断当前子串是否为回文，并更新最长回文子串 res。

3. 返回结果:

   return res
   

   • 返回最长回文子串 res。

这个动态规划的解法时间复杂度为 O(n²），空间复杂度为 O(n²)。