LeetCode - 最长回文子串（Swift）

题目

给定一个字符串 s，找到 s 中最长的回文子串。你可以假设 s 的最大长度为 1000。回文是一个正读和反读都相同的字符串，例如，“aba” 是回文，而“abc” 不是。

示例 1：

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

示例 2：

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

示例 3：

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

示例 4：

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

提示：

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

思路

1、暴力求解

最容易想到的就是暴力破解，求出每一个子串，之后判断是不是回文，找到最长的那个。求每一个子串时间复杂度O(N²)，判断子串是不是回文O(N)，两者是相乘关系，所以时间复杂度为O(N³)。

func isPalindromic(_ s: String) -> Bool {
    let array = Array(s)
    let length = array.count
    for i in 0.. String {
    var maxString = ""
    if s.count < 2 { return s }
    let length = s.count
    for i in 0.. maxString.count {
                maxString = subString
            }
        }
    }
    return maxString
}

添加String扩展简单截取子串

extension String {
    subscript(_ range: CountableRange) -> String {
        let start = index(startIndex, offsetBy: max(0, range.lowerBound))
        let end = index(start, offsetBy: min(self.count - range.lowerBound,
                                             range.upperBound - range.lowerBound))
        return String(self[start.. String {
    var maxString = ""
    if s.count < 2 { return s }
    let length = s.count
    for i in 0.. maxString.count {
                maxString = subString
            }
        }
    }
    return maxString
}

2、中心扩展

中心扩展就是把给定的字符串的每一个字母当做中心，向两边扩展，这样来找最长的子回文串。算法时间复杂度为O(N²)。

具体实现

1、通过遍历，取到第一个字符，设该字符为回文串的中心字符
2、回文串有两种，一种是(abba)，一种是(abcba)，也就是单数或双数两种
3、同时还有相同字符的回文串，例如(aaa)，(bbbb)
4、所以，在遍历一开始，设置start与end为 i，设默认情况为单数回文串
5、然后通过 while 循环，分别对 start 进行左移 ，对 end 进行右移， 判断是否为双数回文串
6、再通过 while 对回文串同时进行 start -= 1 与 end += 1
7、如果获取到的 start -= 1 的字符 与 end += 1 的字符相同， 则扩大回文串。否则退出循环
8、当所有遍历循环结束时， dic字典中，存放着回文串的长度，start与end
9、通过start，end拼接出完整字符串，并return

// 172ms
func longestPalindrome(_ s: String) -> String { 
        var start = 0
        var end = 0
        let stringArray = Array(s)

        var i = 0
        var dic = [String : Int]()

        for element in stringArray {
            start = i
            end = i

            while start - 1 >= 0 { // 左移多位判断
                if stringArray[start - 1] == element {
                    start -= 1
                } else {
                    break
                }
            }

            while end + 1 <= (stringArray.count - 1) {  // 右移多位判断
                if stringArray[end + 1] == element {
                    end += 1
                } else {
                    break
                }
            }

            while start >= 0 && end <= (stringArray.count - 1) { // 判断是否为回文串
                if start != end {
                    if stringArray[start] == stringArray[end] { // 子字符
                        if dic["count"] ?? 0 < (end - start + 1) { // 存储位置信息
                            dic["count"] = end - start + 1
                            dic["start"] = start
                            dic["end"] = end
                        }
                    } else {
                        break
                    }
                }
                //保存起来目前最大的回文串之后继续往外扫
                start -= 1
                end += 1
            }

            i += 1 // 偏移中心比对点
        }

        var newStr: [String] = []
        start = dic["start"] ?? 0
        end = dic["end"] ?? 0

        for index in start ... end {
            newStr.append(stringArray[index].description)
        }

        return newStr.joined() //去掉空格
    }

更快速的中心扩散

// 120 ms
func longestPalindrome(_ s: String) -> String {
    let array = Array(s)
    let length = array.count
    if length < 2 { // 直接返回
        return s
    }
    
    var maxLength = 1
    var begin = 0
    
    for index in 0.. maxLength { // 更新最大值
            maxLength = oeMax
            begin = index - (maxLength-1)/2
        }
    }
    
    // 截取子串
    return String(array[begin.. Int {
    let length = s.count
    var i = left, j = right
    while i>=0 && j < length { // 左边大于等于0，右边小于整个字符串的长度
        if s[i] == s[j] { // 如果左右两边值相等
            i -= 1 // 向外扩散，左边继续往左边移动
            j += 1 // 右边继续往右边移动
        } else {
            break
        }
    }
    
    // 返回回文的长度
    return j-i-1;
}

3、动态规划

回文字符串的子串也是回文，因此用dp[i,j]（表示以i开始以j结束的子串）是回文字符串，那么P[i+1,j-1]也是回文字符串。这样最长回文子串就能分解成一系列子问题了。这样需要额外的空间O(N²)，算法复杂度也是O(N²)。

// 2036ms
func longestPalindrome1(_ s: String) -> String {
    if s.count <= 1 { return s }

    let s = Array(s)
    // 最长回文串的起始位置 和长度
    var maxLen = 1
    var begin = 0
   
    // 二维数组
    var dp = [[Bool]](repeating: [Bool](repeating: false, count: s.count), count: s.count)

    for i in (0.. maxLen { // 更新最大值
                maxLen = len
                begin = i
            }
        }
    }

    return String(s[begin..

参考

• 最长回文子串
  
• leetcode
• 详解回文
  、