[Swift]LeetCode5. 最长回文子串 | Longest Palindromic Substring

★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★
➤微信公众号：山青咏芝（shanqingyongzhi）
➤博客园地址：山青咏芝（https://www.cnblogs.com/strengthen/）
➤GitHub地址：https://github.com/strengthen/LeetCode
➤原文地址：https://www.cnblogs.com/strengthen/p/9860395.html 
➤如果链接不是山青咏芝的博客园地址，则可能是爬取作者的文章。
➤原文已修改更新！强烈建议点击原文地址阅读！支持作者！支持原创！
★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★

Given a string s, find the longest palindromic substring in s. You may assume that the maximum length of s is 1000.

Example 1:

Input: "babad"
Output: "bab"
Note: "aba" is also a valid answer.

Example 2:

Input: "cbbd"
Output: "bb"

---

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

示例 1：

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

示例 2：

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

---

40ms

class Solution {
    func longestPalindrome(_ s: String) -> String {
        guard s.count > 0 else{
            return ""
        }
        guard s.count > 1 else{
            return s
        }
        var str_arr: [Character] = ["#"]
        for ele in Array(s){
            str_arr.append(ele)
            str_arr.append("#")
        }
        // Array to record longest palindrome
        var result_arr = [Int](repeating: 0, count: str_arr.count)
        var center = 0, boundary = 0, maxLen = 0, result_center = 0
        
        //  首位的 "#" 不用管
        for i in 1..<str_arr.count-1{
            // calc mirror i = center-(i-center)
            let iMirror = 2 * center - i
            result_arr[i] = boundary > i ? min(boundary-i, result_arr[iMirror]) : 0
            // Attempt to expand palindrome centered at i
            while i-1-result_arr[i] >= 0 , i + 1 + result_arr[i] <= str_arr.count - 1, str_arr[i+1+result_arr[i]] == str_arr[i-1-result_arr[i]]{
                result_arr[i]+=1
            }
            // update center and boundary
            // 用来记录的
            if i + result_arr[i] > boundary{
                center = i
                boundary = i+result_arr[i]
            }
            // update result
            if result_arr[i] > maxLen{
                maxLen = result_arr[i]
                result_center = i
            }
        }
        let ans = String(s[s.s_index(offset: (result_center-maxLen)/2)..<s.s_index(offset: (result_center+maxLen)/2)])

        return ans
    }
}



extension String{

    func s_index(offset: Int) -> String.Index{
        return self.index(self.startIndex, offsetBy: offset)
    }
    
}

---

44ms

class Solution {
func longestPalindrome(_ s: String) -> String {
    
    if s.count == 0 {
        return ""
    }
    
    if s.count == 1 {
        return s
    }
    
    // 字符串预处理
    var ss = [Character]()
    for c in s {
        ss.append("#")
        ss.append(c)
    }
    ss.append("#")

    var p = Array<Int>(repeating: 0, count: s.count * 2 + 1)
    var i = 1, mx = 0, center = 0, j = 0
    var maxCenter = 0
    while i < ss.count {
        // 说明以i为中心时，已有匹配的回文字符子串
        if mx - i > 0 {
            // i关于对称中心id的对称点
            j = 2 * center - i
            p[i] = min(p[j], mx - i)
        } else {
            p[i] = 1
        }
        if i - p[i] >= 0 && i + p[i] < ss.count {
            while ss[i - p[i]] == ss[i + p[i]] {
                p[i] += 1
                if i - p[i] < 0 || i + p[i] >= ss.count {
                    break
                }
            }
        }
        if p[i] + i > mx {
            mx = p[i] + i
            center = i
        }
        if p[maxCenter] < p[i] {
            maxCenter = i
        }
        i += 1
    }
    let ret = ss[(maxCenter - p[maxCenter] + 1) ... (maxCenter + p[maxCenter] - 1)].filter { $0 != "#"}
    return String(ret)
}
}

---

52ms

class Solution {
    func longestPalindrome(_ s: String) -> String {
        if s.count <= 1 {
            return s;
        }
        
        // 1.间隔之间先插入#
        var newString:String = "#";
        for var character in s {
            newString.append(character);
            newString = newString + "#";
        }
        let characters = Array(newString);
        
        // 2.遍历找出以每个节点作为轴最长半径
        var maxId:Int = 0;
        var max:Int = 0;
        var ids:[Int] = [];
        ids.append(1);
        var maxLength:Int = 1;
        var maxLengthIndex = 0;
        
        for var i in 1...characters.count - 1 {
            var j:Int = maxId - (i - maxId);
            if max > i && j >= 0 {
                ids.append(min(ids[j], max - i));
            }else{
                ids.append(1);
            }
            while i + ids[i] <= characters.count - 1 && i - ids[i] >= 0 && characters[i + ids[i]] == characters[i - ids[i]]{
                ids[i] += 1;
            }
            
            if i + ids[i] - 1 > max {
                maxId = i;
                max = i + ids[i] - 1;
            }
            
            if ids[i] > maxLength{
                maxLength = ids[i];
                maxLengthIndex = i;
            }
        }
        let leftIndex = s.index(s.startIndex, offsetBy: (maxLengthIndex - (maxLength - 1))/2);
        let rightIndex = s.index(leftIndex, offsetBy:maxLength - 1 - 1);
        return String(s[leftIndex...rightIndex]);
    }
}

---

60ms

class Solution {
    func longestPalindrome(_ s: String) -> String {
        guard s.count > 1 else {
            return s
        }
        
        var resultLeftIndex: Int = 0
        var maxLen: Int = 1;
        
        var sArray = Array(s)
        
        // 循环参数
        var index = 0
        
        while index < sArray.count {
            var leftIndex = index
            var rightIndex = index
            
            // 找重复
            while rightIndex + 1 < sArray.count && sArray[rightIndex] == sArray[rightIndex + 1] {
                rightIndex = rightIndex + 1
            }
            
            // 下一次循环从重复数后开始继续找回文
            index = rightIndex + 1
            
            // 找以left~right为中心的回文
            while leftIndex - 1 >= 0 && rightIndex + 1 < sArray.count && sArray[leftIndex - 1] == sArray[rightIndex + 1] {
                leftIndex = leftIndex - 1
                rightIndex = rightIndex + 1
            }
            
            // 判断本次回文的长度，如果最长那么记录它
            let len: Int = rightIndex - leftIndex + 1
            if len > maxLen {
                resultLeftIndex = leftIndex
                maxLen = len
            }
        }
        
        let nss: NSString = NSString.init(string: s)
        
        let result: String = nss.substring(with: NSMakeRange(resultLeftIndex, maxLen))
        return result
    }
}

---

64ms

class Solution {
    func longestPalindrome(_ s: String) -> String {
        if s.count <= 1 {
            return s;
        }
        
        // 1.间隔之间先插入#
        var newString:String = "#";
        for var character in s {
            newString.append(character);
            newString = newString + "#";
        }
        let characters = Array(newString);
        
        // 2.遍历找出以每个节点作为轴最长半径
        var maxId:Int = 0;
        var max:Int = 0;
        var ids:[Int] = [];
        ids.append(1);
        var maxLength:Int = 1;
        var maxLengthIndex = 0;
        
        for var i in 1...characters.count - 1 {
            var j:Int = maxId - (i - maxId);
            if max > i && j >= 0 {
                ids.append(min(ids[j], max - i));
            }else{
                ids.append(1);
            }
            while i + ids[i] <= characters.count - 1 && i - ids[i] >= 0 && characters[i + ids[i]] == characters[i - ids[i]]{
                ids[i] += 1;
            }
            
            if i + ids[i] - 1 > max {
                maxId = i;
                max = i + ids[i] - 1;
            }
            
            if ids[i] > maxLength{
                maxLength = ids[i];
                maxLengthIndex = i;
            }
        }
        let leftIndex = s.index(s.startIndex, offsetBy: (maxLengthIndex - (maxLength - 1))/2);
        let rightIndex = s.index(leftIndex, offsetBy:maxLength - 1 - 1);
        return String(s[leftIndex...rightIndex]);
    }
}

---

76ms

extension String {
    func getSubString(startIndex: Int, endIndex: Int) -> String {
        let start = self.index(self.startIndex, offsetBy: startIndex)
        let end = self.index(self.startIndex, offsetBy: endIndex)
        return String(self[start...end])
    }
    
    func isPalindrome() -> Bool {
        guard self.count >= 1 else {
            return true
        }
        var amount = 0
        let chars = self.map { String($0) }
        for i in 0..<chars.count / 2 {
            if chars[i] == chars[chars.count - 1 - i] {
                amount = amount + 1
            }
        }
        return amount == chars.count / 2
    }
}

class Solution {
func longestPalindrome(_ s: String) -> String {
    if s.count <= 1 {
        return s
    }
    var C = 0
    var R = 0

    let chars = s.map { String($0) }
    var transformArr: [String] = []
    transformArr.append("^")
    for char in chars {
        transformArr.append("#")
        transformArr.append(char)
    }
    transformArr.append("#")
    transformArr.append("$")
    
    var P = Array(repeating: 0, count: transformArr.count)
    
    for i in 1..<transformArr.count - 1 {
        let i_mirror = 2 * C - i
        if R > i {
            P[i] = min(R - i, P[i_mirror])// 防止超出 R
        } else {
            P[i] = 0;// 等于 R 的情况
        }
        
        while transformArr[i + 1 + P[i]] == transformArr[i - 1 - P[i]] {
            P[i] = P[i] + 1
        }
        
        if i + P[i] > R {
            C = i
            R = i + P[i]
        }
    }

    var maxLen = 0
    var centerIndex = 0
    for i in 1..<transformArr.count - 1 {
        if P[i] > maxLen {
            maxLen = P[i]
            centerIndex = i
        }
    }
    let start = (centerIndex - maxLen) / 2 //最开始讲的
    
    return s.getSubString(startIndex: start, endIndex: start + maxLen - 1)
}
}

---

96ms

class Solution {
    func longestPalindrome(_ s: String) -> String {
        guard s.count > 1 else {
            return s
        }
        
        var str = ""
        
        for i in 0..<s.count {
            let idx = String.Index(encodedOffset: i)
            str.append(String(s[idx]))
            str.append("#")
        }
        
        var p: [Int] = [1]
        var ct = 0         // 中心位置
        var mr = 1         // 回文字串的最大右边界
        
        var chars = [Character](str)
        
        
        for i in 1..<str.count {
            let val = mr > i ? min(p[2 * ct - i], mr-i) : 1  // p[i]的值为其对称的值p[j]和右边界到i的值的最小值
            p.append(val)
            
            // 如果对称位置的字符相等则加1
            while i-p[i] >= 0
                && i+p[i] < chars.count
                && chars[i-p[i]] == chars[i+p[i]] {
                    p[i] += 1
            }
            
            // 更新中心位置和最大右边界位置
            if i + p[i] > mr {
                mr = i + p[i]
                ct = i
            }
        }
        
        if let val = p.max() {
            let index = p.index(of: val)
            let start = String.Index(encodedOffset: index!-val+1)
            let end = String.Index(encodedOffset: index!+val)
            return String(str[start..<end]).replacingOccurrences(of: "#", with: "")
        }
        
        
        return ""
    }
}

---

140ms

class Solution {
    func longestPalindrome(_ s: String) -> String {
        // Base case
        guard s.count > 0 else { return "" }
        
        // Convert String to Array for simplicity of use
        let chars = Array(s)
        
        var start = 0, end = 0
        
        // Loop through
        for i in 0..<chars.count {
            let length = chars.expandFromCenter(i, i)
            let length2 = chars.expandFromCenter(i, i + 1)
            
            let resultedMax = max(length, length2)

            if resultedMax > (end - start) {
                start = i - (resultedMax - 1)/2
                end = i + resultedMax/2
            }
        }
        
        let result = String(chars[start...end])
        print(result)
        
        // Return string
        return result
    }
}

extension Array where Array.Element: Equatable {
    func expandFromCenter(_ lhs: Int, _ rhs: Int) -> Int {
        var left = lhs, right = rhs
        while left >= 0, right < count, self[left] == self[right] {
            left -= 1
            right += 1
        }
        
        return right - left - 1
    }
}

---

152ms

class Solution {
    func longestPalindrome(_ s: String) -> String {
        let count = s.count
        if  count < 2{
            return s
        }
        
        var charArr = [Character]()
        for char in s {
            charArr.append(char)
        }
        
        var start = 0
        var end = 0
        for i in 0..<count {
            var left = i
            var right = i
            
            while left >= 0 && right < count && charArr[left] == charArr[right] {
                left -= 1
                right += 1
            }
            let len1 = right - left - 1;
            left = i
            right = i + 1
            while left >= 0 && right < count && charArr[left] == charArr[right] {
                left -= 1
                right += 1
            }
            let len2 = right - left - 1;
            let len = max(len1,len2)
            if len > end - start {
                start = i - (len - 1) / 2
                end = i + len / 2
            }
        }
        if start == end {
            return String(s[s.startIndex])
        }
        
        return String(s[s.index(s.startIndex, offsetBy: start)...s.index(s.startIndex, offsetBy: end)]);
    }
}

---

 168ms

class Solution {
    func longestPalindrome(_ s: String) -> String {
        guard s.count > 0 else {
            return ""
        }
        var s = Array(s)
        var maxLength = 0, curLength = 0
        var minLeft = 0, maxRight = 0
        var i = 0
        let count = s.count
        while i < count {
            var left = i, right = i
            while left - 1 >= 0 && s[left - 1] == s[i] {
                left -= 1
            }
            
            while right + 1 < count && s[right + 1] == s[i] {
                right += 1
            }
            
            while left - 1 >= 0 && right + 1 < count && s[left - 1] == s[right + 1] {
                left -= 1
                right += 1
            }
            curLength = right - left + 1
            if curLength > maxLength {
                maxLength = curLength
                minLeft = left
                maxRight = right
            }
            i += 1
        }
        
        var result = ""
        for j in minLeft...maxRight {
            result += String(s[j])
        }
        
        return result
    }
}

---

188ms

class Solution {
  func longestPalindrome(_ s: String) -> String {
    if s == "" {
        return "";
    }
    var start = 0, end = 0
    var store:[Character:[Int]] = [Character:[Int]]()
    let lenght = s.count
    let chars:[Character] = [Character] (s)
    var result = ""
    for i in 0..<lenght {
        let length1 = testPalindrow(chars,i,i)
        let length2 = testPalindrow(chars,i,i+1)
        let length = max(length1, length2)
        if (length > end - start) {
            start = i - (length - 1) / 2
            end = i + length/2
        }
    } 
     
    return String(chars[start...end])
}

func testPalindrow (_ s:[Character], _ left:Int, _ right:Int) -> Int {
    var count = s.count
    var L = left
    var R = right
    while (L>=0 && R < count && s[L] == s[R]) {
        L -= 1
        R += 1
    }
    return R-L-1
}
}

---

192ms

class Solution {
    func longestPalindrome(_ s: String) -> String {
        guard s.count > 0 else{
            return ""
        }
        let str_arr = Array(s)
        var start = 0, end = 0
        for i in 0..<str_arr.count{
            let len_one = str_arr.expandAroundCenter(lhs: i, rhs: i)
            let len_two = str_arr.expandAroundCenter(lhs: i, rhs: i+1)
            let len = max(len_one, len_two)
            if len > end - start {
                start = i - (len - 1)/2
                end = i + len/2
            }
        }
        let result: String = String(str_arr[start...end])
        print(result)
        return result
    }
}

---

208ms

class Solution {
    func longestPalindrome(_ s: String) -> String {
        if s.count <= 1 {
            return s
        }
        var stringArray: Array<Character> = Array(s)
        var maxLength: Int = 0
        var startIndex: Int = 0
        // 2 * n - 1
        for i in 0..<2 * stringArray.count - 1 {
            var leftIndex: Int
            var rightIndex: Int
            leftIndex = i / 2
            rightIndex = (i + 1) / 2
            while stringArray[leftIndex] == stringArray[rightIndex] {
                if rightIndex - leftIndex + 1 > maxLength {
                        maxLength = rightIndex - leftIndex + 1
                        startIndex = leftIndex
                }
                
                if leftIndex - 1 >= 0 && rightIndex + 1 < stringArray.count {
                    leftIndex -= 1
                    rightIndex += 1
                } else {
                    break
                }
            }
        }
        return String(stringArray[startIndex..<startIndex + maxLength])
    }
}

---

2708ms：Manacher算法

class Solution {
    //Manacher算法
    func longestPalindrome(_ s: String) -> String {
        if s == nil || s.count < 1 {return ""}
        else if s.count == 1{return s}
        var s = s
        //注意，为了避免更新P的时候导致越界，我们在字符串T的前增加一个特殊字符，
        //比如说‘$’,所以算法中字符串是从1开始的。、
        var manaStr = "$#"
        for i in 0..<s.count
        {
            //首先构造出新的字符串
            manaStr += String(getChar(s,i))
            manaStr += "#"
        }
        //用一个辅助数组来记录最大的回文串长度，注意这里记录的是新串的长度，原串的长度要减去1
        var rd:[Int] = [Int](repeating: 0,count: manaStr.count)
        var pos = 0, mx = 0
        var start = 0, maxLen = 0
        for i in 1..<manaStr.count
        {
            rd[i] = i < mx ? min(rd[2 * pos - i], mx - i) : 1
            //这里要注意数组越界的判断，源代码没有注意，release下没有报错
            while(i + rd[i] < manaStr.count && i - rd[i] > 0 && getChar(manaStr,i  + rd[i]) == getChar(manaStr,i - rd[i]))
            {
                rd[i] += 1
            }
            //如果新计算的最右侧端点大于mx,则更新pos和mx
                  if mx < i + rd[i]
                  {
                pos = i
                mx = i + rd[i]
            }
            if rd[i] - 1 > maxLen
            {
                start = (i - rd[i]) / 2
                maxLen = rd[i] - 1
            }
        }
        let index3 = s.index(s.startIndex,offsetBy:start)
        let index4 = s.index(index3,offsetBy:maxLen - 1)
        return String(s[index3...index4])
    }
        
    func getChar(_ str:String,_ i:Int) -> Character
    {
        return str[str.index(str.startIndex,offsetBy:i)]
    }
}