[Swift]LeetCode336. 回文对 | Palindrome Pairs

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

Given a list of unique words, find all pairs of distinct indices (i, j) in the given list, so that the concatenation of the two words, i.e. words[i] + words[j] is a palindrome.

Example 1:

Input: ["abcd","dcba","lls","s","sssll"]
Output: [[0,1],[1,0],[3,2],[2,4]] 
Explanation: The palindromes are ["dcbaabcd","abcddcba","slls","llssssll"]

Example 2:

Input: ["bat","tab","cat"]
Output: [[0,1],[1,0]] 
Explanation: The palindromes are ["battab","tabbat"]

---

给定一组唯一的单词， 找出所有不同 的索引对(i, j)，使得列表中的两个单词， words[i] + words[j] ，可拼接成回文串。

示例 1:

输入: ["abcd","dcba","lls","s","sssll"]
输出: [[0,1],[1,0],[3,2],[2,4]] 
解释: 可拼接成的回文串为 ["dcbaabcd","abcddcba","slls","llssssll"]

示例 2:

输入: ["bat","tab","cat"]
输出: [[0,1],[1,0]] 
解释: 可拼接成的回文串为 ["battab","tabbat"]

---

1068ms

class Solution {
    class TridNode {
        var nexts : [Character : TridNode] = [Character : TridNode]()
        var index : Int = -1
        var parIndexs = [Int]()
    }
    
    func palindromePairs(_ words: [String]) -> [[Int]] {
        
        var res = [[Int]]()
        
        let root = TridNode()
        
        for i in 0..<words.count {
            buildTrees(root, Array(words[i]), i)
        }
        
        for i in 0..<words.count {
            search(Array(words[i]), i, root, &res)
        }
        
        return res
    }
    
    func buildTrees(_ root : TridNode, _ wordArr : [Character] , _ index : Int ) {
        var root = root
        for i in stride(from: wordArr.count - 1, to: -1, by: -1) {
            let c = wordArr[i]
            if root.nexts[c] == nil {
                root.nexts[c] = TridNode()
            }
            if isPalindrome(wordArr, 0, i) {
                root.parIndexs.append(index)
            }
            
            root = root.nexts[c]!
        }
        
        root.parIndexs.append(index)
        root.index = index
    }
    
    func search(_ wordArr : [Character], _ i : Int , _ root : TridNode , _ res : inout [[Int]]) {
        var root = root
        for j in 0..<wordArr.count {
            if root.index >= 0 && root.index != i && isPalindrome(wordArr, j, wordArr.count - 1) {
                res.append([i,root.index])
            }
            
            guard root.nexts[wordArr[j]] != nil else {
                return
            }
            
            root = root.nexts[wordArr[j]]!
        }
        
        for j in root.parIndexs where i != j {
            res.append([i,j])
        }
        
    }
    
    
    func isPalindrome(_ wordArr : [Character], _ i : Int , _ j : Int) -> Bool {
        
        var i = i, j = j
        
        while i < j {
            if wordArr[i] != wordArr[j] {
                return false
            }
            i += 1
            j -= 1
        }
        
        return true
    }
}

---

1280ms

class Solution {
    let lowerLetterUnicodeStart = Character("a").char2Int()

    func palindromePairs(_ words: [String]) -> [[Int]] {
        var result = [[Int]]()
        let n = words.count
        let root = TrieNode()

        func addWord(_ root: TrieNode, _ index: Int) {
            var point = root
            let word = Array(words[index])
            for i in (0..<word.count).reversed() {
                let char = word[i].char2Int() - lowerLetterUnicodeStart
                if point.next[char] == nil { point.next[char] = TrieNode() }
                if isPalindrome(word, 0, i) { point.list.append(index) }
                if let next = point.next[char] { point = next }
            }
            point.list.append(index)
            point.index = index
        }

        func search(_ root: TrieNode, _ index: Int) {
            var point = root
            let word = Array(words[index])
            for i in 0..<word.count {
                let idx = point.index
                if idx >= 0, idx != index, isPalindrome(word, i, word.count - 1) {
                        result.append([index, idx])
                    
                }
                let char = word[i].char2Int() - lowerLetterUnicodeStart
                if let next = point.next[char] { point = next } else { return }
            }
            for i in point.list where index != i { result.append([index, i]) }
        }

        for i in 0..<n { addWord(root, i) }
        for i in 0..<n { search(root, i) }
        return result
    }

    func isPalindrome(_ word: [Character], _ i: Int, _ j: Int) -> Bool {
        var (i, j) = (i, j)
        while i < j {
            if word[i] != word[j] { return false }
            i += 1
            j -= 1
        }
        return true
    }
}

class TrieNode {
    var next: [TrieNode?] = Array(repeating: nil, count: 26)
    var index = -1
    var list = [Int]()
}

extension Character {
    func char2Int() -> Int {
        return Int(self.unicodeScalars.first!.value)
    }
}

---

1516ms

class Solution {
    func palindromePairs(_ words: [String]) -> [[Int]] {
        var rslts = [[Int]]()
        if words.count == 0 {
            return rslts
        }
        
        class Node {
            var label: Int?
            var dict: [Character: Node]
            
            init() {
                label = nil
                dict = [:]
            }
            
            func isPalindrome(_ charArr: [Character], from index: Int) -> Bool {
                if index >= charArr.count {
                    return true
                }
            
                var left = index
                var right = charArr.count-1
            
                while left < right {
                    let lch = charArr[left]
                    let rch = charArr[right]
                    if lch != rch {
                        return false
                    }
                    left += 1
                    right -= 1
                }
                return true
            }
            
            func insert(_ charArr: [Character], _ index: Int, _ label: Int) -> Void {
                // print("insert", index)
                if index >= charArr.count {
                    self.label = label
                    return
                }
                
                let ch = charArr[index]
                var node = dict[ch]
                if node == nil {
                    node = Node()
                    dict[ch] = node
                }
                node?.insert(charArr, index+1, label)
            }
            
            func search(_ charArr: [Character], _ index: Int, _ mLabel: Int, _ labels: inout [Int]) -> Void {
                // print("search", index)     
                if let label = label, label != mLabel {
                    if isPalindrome(charArr, from: index) == true {
                        labels.append(label)     
                    }
                }
                
                if index >= charArr.count {
                    return
                }
                                
                let ch = charArr[index]
                guard let node = dict[ch] else {
                    return
                }
                node.search(charArr, index+1, mLabel, &labels)
            }
        }
        
        var trie = Node()
        for (i, word) in words.enumerated() {
            trie.insert(Array(word), 0, i)
        }
        
        for (i, word) in words.enumerated() {
            var labels = [Int]()
            trie.search(Array(word.reversed()), 0, i, &labels)
            for label in labels {
                rslts.append([label, i])
            }
        }
        
        trie = Node()
        for (i, word) in words.enumerated() {
            trie.insert(Array(word.reversed()), 0, i)
        }
        
        for (i, word) in words.enumerated() {
            var labels = [Int]()
            trie.search(Array(word), 0, i, &labels)
            for label in labels {
                rslts.append([i, label])
            }
        }
        return Array(Set(rslts))
    }
}

---

4620ms

class Solution {
    func palindromePairs(_ words: [String]) -> [[Int]] {
        var wd = [String : Int]()
        var ld = Set<Int>()
        var res = [[Int]]()
        for (i, word) in words.enumerated() {
            wd[word] = i
            ld.insert(word.count)
        }
        
        for i in 0 ..< words.count {
            var word = words[i]
            var reword = String(word.reversed())
            if let index = wd[reword], index != i {
                res.append([i, index])
            }
            var w1 = Array(word)
            for l in 0 ..< w1.count {
                if ld.contains(l) {
                    if l == 0 && isValid(w1, 0, w1.count-1) {
                        res.append([i, wd[""]!])
                        res.append([wd[""]!, i])
                    } else {
                        if let index = wd[String(Array(w1[0 ..< l]).reversed())], isValid(w1, l, w1.count-1) {
                            res.append([i, index])
                        }
                        if let index = wd[String(Array(w1[w1.count-l ..< w1.count]).reversed())], isValid(w1, 0, w1.count-l-1) {
                            res.append([index, i])
                        }  
                    } 
                }
            }
        }
        return res
    }
    
    func isValid(_ w: [Character], _ left: Int, _ right: Int) -> Bool {
        var l = left
        var r = right
        while l <= r {
            if w[l] != w[r] {
                return false
            } else {
                l += 1
                r -= 1
            }
        }
        return true
    }
}

---

7924ms

class Solution {
    
    func palindromePairs(_ words: [String]) -> [[Int]] {
        var indexes = [String: Int]()
        var result = [[Int]]()
        for (i, w) in words.enumerated() {
            indexes[w] = i
        }
        for (i, w) in words.enumerated() {
            for j in (0...w.count) {
                let prefix = subword(w, 0..<j)
                let suffix = subword(w, j..<w.count)
                if isPalindrome(prefix) {
                    let end = String(suffix.reversed())
                    if end != w, let index = indexes[end] {
                        result.append([index, i])
                    }
                }
                if j != w.count && isPalindrome(suffix) {
                    let end = String(prefix.reversed())
                    if end != w, let index = indexes[end] {
                        result.append([i, index])
                    }
                }
            }
        }
        
        return result
    }
    
    func isPalindrome(_ word: String) -> Bool {
        return String(word.reversed()) == word
    }
    
    func subword(_ word: String, _ range: Range<Int>) -> String {
        return Array(word)[range].map { String($0) }.joined(separator: "")
    }
}