LeetCode 5. 最长回文子串

5. 最长回文子串

   

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

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

示例 1：

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

示例 2：

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

提示：

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

思路：

方法1 中心拓展

参考 LeetCode大佬题解

此题可以在 [647. 回文子串] 题的基础上，加上对最长回文子串的逻辑判断。

因为回文串是中心对称的，我们可以先枚举子串的中心，然后**从中心处向两边探测**，直到发现两端字符不相等或者到达字符串边缘。

s长度为 奇数，中心是单个字符，以 s[i] 为中心向两边扩展
s长度为 偶数，中心是两个字符，以 s[i]、s[i+1] 为中心向两边扩展

方法2 动态规划

参考视频：史上最燃算法刷题！Leetcode 5. 最长回文子串_哔哩哔哩_bilibili

找出状态转移方程如下：

• 对于 j - i > 2 的情况：dp[i][j]的状态转移方程可能取决于dp[i+1][j-1]，所以不能使用常规从前往后的二位数组遍历方式；可以将i从后往前遍历，将j在i+1的基础上向后遍历。也就是先获取后面dp[i+1][j-1]的状态值，再进而推导出前面dp[i][j]的状态值
• 注意：单独字符本身也属于最小的回文子串，比如单独的字符：a

时间复杂度：O(N²)，其中 N 是字符串的长度，动态规划的状态总数为 O(N²)

空间复杂度：O(N²)，需要额外申请二维数组dp[i][j]来存储每个状态值

// 中心拓展法（个人认为以下代码相对于动态规划来讲，更加清晰明了）：
// 此题可以在 [647. 回文子串] 题的基础上，加上对最长回文子串的逻辑判断
// [647. 回文子串] 参考题解：https://leetcode.cn/problems/palindromic-substrings/solutions/369611/manacher-zhi-hui-qiu-zui-chang-hui-wen-zi-chuan-ta/
func longestPalindrome(s string) string {
    sLength, res := len(s), ""
	
    for i := 0; i < sLength; i++ {
    	// s长度为奇数，中心是单个字符，以s[i]为中心向两边扩展
        l, r := i, i 
        for l >= 0 && r < sLength && s[l] == s[r] {
        	// 通过比较找出更长的最长回文子串
            tmpLength := r - l + 1
            if tmpLength > len(res) {
                res = s[l:r+1]
            }

            l--
            r++
        }

		// s长度为偶数，中心是两个字符，以s[i]、s[i+1]为中心向两边扩展
        l, r = i, i + 1 
        for l >= 0 && r < sLength && s[l] == s[r] {
        	// 通过比较找出更长的最长回文子串
            tmpLength := r - l + 1
            if tmpLength > len(res) {
                res = s[l:r+1]
            }

            l-- 
            r++
        }
    }
    return res
}

// 动态规划1：参考b站视频：https://www.bilibili.com/video/BV1dN4y1g7p9?spm_id_from=333.337.search-card.all.click&vd_source=2c268e25ffa1022b703ae0349e3659e4
// arr[i][j]的状态转移方程可能取决于arr[i+1][j-1]，所以不能使用常规的二位数组遍历方式；
// 可以将i从后往前遍历，将j在i+1的基础上向后遍历；
// 也就是先从后向前获取arr[i+1][j-1]的状态值，再进而获取arr[i][j]的状态值。
func longestPalindrome(s string) string {
	length := len(s)
	// if length <= 1 {
	//     return s
	// }

	// 题目要求：1 <= s.length <= 1000，所以最小子串为单独字符本身
	var res string = s[0:1]

	// 初始化二维数组
	dp := make([][]bool, length)
	for i := 0; i < length; i++ {
		dp[i] = make([]bool, length)
	}

	for i := length - 1; i >= 0; i-- {
		for j := i + 1; j < length; j++ {
			if i == j {
				dp[i][j] = true
			} else if j-i <= 2 { // s[i] == s[j] 并且i、j间距小于等于2的子串都为true，比如aba(2-0=2) aa(1-0=1) a(0-0=0)等于0也就是单独字符本身
				dp[i][j] = s[i] == s[j]
			} else {
				dp[i][j] = s[i] == s[j] && dp[i+1][j-1]
			}

			if dp[i][j] && j-i+1 >= len(res) {
				res = s[i : i+j-i+1]
			}
		}
	}

	return res
}

// 动态规划2：参考b站视频：https://www.bilibili.com/video/BV1AA411B7XV?spm_id_from=333.337.search-card.all.click&vd_source=2c268e25ffa1022b703ae0349e3659e4
func longestPalindrome(s string) string {
    length := len(s)
    if length <= 1 {
        return s
    }

    // 初始化二维数组并将对角线dp[i][i]为true。即i=j时，i开始j结尾的字符串
    dp := make([][]bool, length)
    for i := 0; i < length; i++ {
        dp[i] = make([]bool, length)
    }

    for i := 0; i < length; i++ {
        dp[i][i] = true
    }

    max, start := 1, 0 // 注意：max初始为1，一个字符本身也算是回文子串
    // todo: i和j循环位置调换
    for j := 1; j < length; j++ {
        for i := 0; i < length-1 && i < j; i++ {
            if s[i] != s[j] { // asc码值比较
                dp[i][j] = false
            } else {
                if j - i <= 2 { // s[i] == s[j] 并且i、j间距小于等于2的子串都为true，比如aba(2-0=2) aa(1-0=1) a(0-0=0)等于0也就是单独字符本身
                    dp[i][j] = true
                } else {
                    dp[i][j] = dp[i+1][j-1] // ???
                }
            }

            if dp[i][j] && j-i+1 > max {
                max = j-i+1
                start = i
            }
        }
    }

    return s[start:start+max]
}