[Swift]LeetCode648. 单词替换 | Replace Words

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

In English, we have a concept called root, which can be followed by some other words to form another longer word - let's call this word successor. For example, the root an, followed by other, which can form another word another.

Now, given a dictionary consisting of many roots and a sentence. You need to replace all the successor in the sentence with the root forming it. If a successor has many roots can form it, replace it with the root with the shortest length.

You need to output the sentence after the replacement.

Example 1:

Input: dict = ["cat", "bat", "rat"]
sentence = "the cattle was rattled by the battery"
Output: "the cat was rat by the bat" 

Note:

1. The input will only have lower-case letters.
2. 1 <= dict words number <= 1000
3. 1 <= sentence words number <= 1000
4. 1 <= root length <= 100
5. 1 <= sentence words length <= 1000

---

在英语中，我们有一个叫做 词根(root)的概念，它可以跟着其他一些词组成另一个较长的单词——我们称这个词为 继承词(successor)。例如，词根an，跟随着单词 other(其他)，可以形成新的单词 another(另一个)。

现在，给定一个由许多词根组成的词典和一个句子。你需要将句子中的所有继承词用词根替换掉。如果继承词有许多可以形成它的词根，则用最短的词根替换它。

你需要输出替换之后的句子。

示例 1:

输入: dict(词典) = ["cat", "bat", "rat"]
sentence(句子) = "the cattle was rattled by the battery"
输出: "the cat was rat by the bat"

注:

1. 输入只包含小写字母。
2. 1 <= 字典单词数 <=1000
3. 1 <=  句中词语数 <= 1000
4. 1 <= 词根长度 <= 100
5. 1 <= 句中词语长度 <= 1000

---

448ms

class Solution {
    
    private let trie = Trie()
    
    func replaceWords(_ dict: [String], _ sentence: String) -> String {
        dict.forEach { word in
            trie.insert(word)
        }
        
        var words = [String]()
        sentence.split(separator: " ").forEach { word in
            words.append(trie.replacement(String(word)))
        }
        return words.joined(separator: " ")
    }    
}

class Trie {
    
    private let root = TrieNode()
    
    func insert(_ word: String) {
        var node = root
        word.forEach { c in
            let next = node.insert(c)
            node = next
        }
        node.len = word.count
    }
    
    func replacement(_ word: String) -> String {
        var replace = ""
        var node = root
        for c in word {
            guard let next = node.search(c) else {
                break
            }
            replace += String(c)
            if next.len > 0 {
                return replace
            }
            node = next
        }
        return word
    }    
}

class TrieNode {
    
    var len = 0
    private var map = [Character: TrieNode]()
    
    func search(_ c: Character) -> TrieNode? {
        return map[c]
    }
    
    func insert(_ c: Character) -> TrieNode {
        if let node = map[c] {
            return node
        }
        let node = TrieNode()
        map[c] = node
        return node
    }    
}

---

532ms

class Solution {
    func replaceWords(_ dict: [String], _ sentence: String) -> String {
        var trie = Trie()
        
        for word in dict {
            trie.insert(word)
        }
        
        var arr = sentence.split(separator: Character(" "))
        var res = [String]()
        for word in arr {
            res.append(trie.searchForAbbr(String(word)))
        }
        return res.joined(separator: " ")
    }
}

class Trie {
    class TrieNode: CustomStringConvertible {
        var description: String {
            return "(char) children: (children.keys)"
        }
        
        var char: Character = Character(" ")
        var isWordEnding: Bool = false
        var children: [Character: TrieNode] = [Character: TrieNode]()
        
        init(char: Character = " ", isWordEnding: Bool = false, children: [Character: TrieNode] = [:]) {
            self.char = char
            self.isWordEnding = isWordEnding
            self.children = children
        }
    }
    var root: TrieNode
    /** Initialize your data structure here. */
    init() {
        root = TrieNode()
    }
    func searchForAbbr(_ word: String) -> String {
        var str = ""
        var cur = root
        for (index,c) in word.enumerated() {
            str = str + String(c)
            if cur.children[c] == nil {
                return word
            } else {
                let next = cur.children[c]!
                if(next.isWordEnding) {
                    return str
                }
                cur = next
            }
        }
        return word
    }
    /** Inserts a word into the trie. */
    func insert(_ word: String) {
        var cur = root
        for (index, c) in word.enumerated() {
            if cur.children[c] == nil {
                cur.children[c] = TrieNode(char: c, isWordEnding: index == word.count - 1 , children: [:])
            } else {
                if index == word.count - 1 {
                    cur.children[c]!.isWordEnding = true
                }
            }
            cur = cur.children[c]!
        }
    }
    
    /** Returns if the word is in the trie. */
    func search(_ word: String) -> TrieNode? {
        var cur = root
        
        for c in word {
            if cur.children[c] == nil {
                return nil
            } else {
                let next = cur.children[c]!
                cur = next
            }
        }
        return cur
    }
    
    /** Returns if there is any word in the trie that starts with the given prefix. */
    func startsWith(_ prefix: String) -> Bool {
        var cur = root
        for c in prefix {
            if cur.children[c] == nil {
                return false
            }
            cur = cur.children[c]!
        }
        return true
    }
}

---

544ms

class Solution {
    class TrieNode {
        var terminal = false
        var children = [Character: TrieNode]()
    }
    
    class Trie {
        var root = TrieNode()

        func addWord(_ word: String) {
            var n = root
            for ch in word.characters {
                if let child = n.children[ch] {
                    n = child
                } else {
                    let newNode = TrieNode()
                    n.children[ch] = newNode
                    n = newNode
                }
            }
            n.terminal = true
        }
        
        func getWordRoot(_ word: String) -> String {
            var n = root
            let arr = Array(word.characters)
            for i in 0..<arr.count {
                guard let child = n.children[arr[i]] else { return word }
                n = child
                if n.terminal {
                    return String(arr[...i])
                }
            }
            return word
        }
    }
    
    func replaceWords(_ dict: [String], _ sentence: String) -> String {
        let trie = Trie()
        dict.forEach{ trie.addWord($0) }
        
        let words = Array(sentence.components(separatedBy: " "))
        return words.map{ trie.getWordRoot($0) }.joined(separator: " ")
    }
}

---

Runtime: 548 ms

Memory Usage: 22.9 MB

class Solution {
    func replaceWords(_ dict: [String], _ sentence: String) -> String {
        var dict = dict
        var res:String = String()
        var t:String = String()
        var v:[[String]] = [[String]](repeating:[String](),count:26)
        var arr:[String] = sentence.components(separatedBy:" ")
        dict = dict.sorted { $0.count < $1.count }
        for word in dict
        {
            v[word[0].ascii - 97].append(word)
        }
        for str in arr
        {
            t = str
            for word in v[t[0].ascii - 97]
            {
                if t.subString(0, word.count) == word
                {
                    t = word
                    break
                }
            }
            res += t + " "
        }
        res.removeLast()
        return res
    }
}

//String扩展
extension String {        
    //subscript函数可以检索数组中的值
    //直接按照索引方式截取指定索引的字符
    subscript (_ i: Int) -> Character {
        //读取字符
        get {return self[index(startIndex, offsetBy: i)]}
    }
    
    // 截取字符串：指定索引和字符数
    // - begin: 开始截取处索引
    // - count: 截取的字符数量
    func subString(_ begin:Int,_ count:Int) -> String {
        let start = self.index(self.startIndex, offsetBy: max(0, begin))
        let end = self.index(self.startIndex, offsetBy:  min(self.count, begin + count))
        return String(self[start..<end]) 
    }
}

//Character扩展 
extension Character  
{  
  //Character转ASCII整数值(定义小写为整数值)
   var ascii: Int {
       get {
           return Int(self.unicodeScalars.first?.value ?? 0)
       }       
    }    
}

---

568ms

class Solution {
    class Node {
        var value: Character?
        var children: [Character : Node] = [:]
        var isTerminating = false
        
        init(value: Character? = nil) {
            self.value = value
        }
        
        func add(_ letter: Character) {
            guard children[letter] == nil else { return }
            children[letter] = Node(value: letter)
        }
    }
    
    var root = Node()
    
    func addWord(_ word: String) {
        guard !word.isEmpty else { return }
        
        var currentNode = root
        
        for letter in word {
            if currentNode.children[letter] == nil {
                currentNode.add(letter)
            }
            
            guard let node = currentNode.children[letter] else { continue }
            currentNode = node
        }
        
        currentNode.isTerminating = true
    }
    
    func findRoot(_ word: String) -> String? {
        var result = ""
        var currentNode = root
        
        for letter in word {
            if let node = currentNode.children[letter] {
                currentNode = node
                if let value = node.value {
                     result += String(value)
                }
                
                if currentNode.isTerminating {
                    return result
                }
            } else {
                if currentNode.isTerminating {
                    return result
                } else {
                    return nil
                }
            }
        }
        
        return result.isEmpty ? nil : result
    }
    
    func replaceWords(_ dict: [String], _ sentence: String) -> String {
        var result = ""
        
        for word in dict {
            addWord(word)
        }
        
        var currentWord = ""
        
        for char in sentence {
            if char == " " {
                result += (findRoot(currentWord) ?? currentWord) + " "
                currentWord = ""   
            } else {
                currentWord += String(char)
            }
        }
        
        result += findRoot(currentWord) ?? currentWord
        return result
    }
}

---

632ms

class Solution {
    class TrieNode<Key : Hashable>{
    public var key : Key?
    public var isTerminating : Bool = false
    public var children : [Key : TrieNode] = [:]
    public init(_ key : Key?){
        self.key = key
    }
}

func replaceWords(_ dict: [String], _ sentence: String) -> String {
    let trie = Trie<String>.init()
    for str in dict{
        trie.insert(str)
    }
    var results : [String] = []
    let components = sentence.components(separatedBy: " ")
    for component in components{
        if let replacement = trie.findPrefixesWithCollection(component, prefix: ""){
            results.append(replacement)
        }else{
            results.append(component)
        }
    }
    
    return results.joined(separator: " ")
}

class Trie<CollectionType : RangeReplaceableCollection> where CollectionType.Element : Hashable{
    public typealias Node = TrieNode<CollectionType.Element>
    private let root = Node.init(nil)
    public init(){}
    
    // Insertion
    public func insert(_ collection : CollectionType){
        var current = root
        for element in collection{
            if current.children[element] == nil{
                current.children[element] = Node.init(element)
            }
            current = current.children[element]!
        }
        current.isTerminating = true
    }
    
    public func findPrefixesWithCollection(_ collection : CollectionType, prefix : CollectionType)->CollectionType?{
        var current = root
        var result = prefix
        
        for element in collection{
            if current.isTerminating == true{
                break
            }else{
                if current.children[element] == nil{
                    return nil
                }else{
                    result.append(element)
                    current = current.children[element]!
                }
            }
        }
        // now we have gotten the shortest word
        return result
    }
  }
}

---

692ms

class Solution {
    func replaceWords(_ dict: [String], _ sentence: String) -> String {
        let trie = Trie()
        for root in dict {
            trie.insert(root)
        }
        
        var retval: [String] = []
        let words = sentence.components(separatedBy: " ")
        for word in words {
            retval.append(trie.startsWith(word) ?? word)
        }
        return retval.joined(separator: " ")
    }
}



class TrieNode {
    var key: Character?
    var children: [Character: TrieNode] = [:]
    var isTerminator = false
    
    init() {
    }
    
    init(_ key: Character) {
        self.key = key
    }
}


class Trie {
    private let root: TrieNode 
    /** Initialize your data structure here. */
    init() {
        root = TrieNode()
    }
    
    /** Inserts a word into the trie. */
    func insert(_ word: String) {
        var node = root
        for char in word {
            if let some = node.children[char] {
                node = some
            } else {
                let n = TrieNode(char)
                node.children[char] = n
                node = n
            }
        }
        node.isTerminator = true
    }
    
    /** Returns if there is any word in the trie that starts with the given prefix. */
    func startsWith(_ prefix: String) -> String? {
      var retVal = ""
      var node = root
        for char in prefix {
            if let some = node.children[char] {
                node = some
                retVal.append(node.key!)
                if node.isTerminator {
                    return retVal
                }
            } else {
                return nil
            }
        }
        return retVal
    }
}