[Swift]LeetCode676. 实现一个魔法字典 | Implement Magic Dictionary

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

热烈欢迎，请直接点击！！！

进入博主App Store主页，下载使用各个作品！！！

注：博主将坚持每月上线一个新app！！！

Implement a magic directory with buildDict, and search methods.

For the method buildDict, you'll be given a list of non-repetitive words to build a dictionary.

For the method search, you'll be given a word, and judge whether if you modify exactly one character into another character in this word, the modified word is in the dictionary you just built.

Example 1:

Input: buildDict(["hello", "leetcode"]), Output: Null
Input: search("hello"), Output: False
Input: search("hhllo"), Output: True
Input: search("hell"), Output: False
Input: search("leetcoded"), Output: False 

Note:

1. You may assume that all the inputs are consist of lowercase letters a-z.
2. For contest purpose, the test data is rather small by now. You could think about highly efficient algorithm after the contest.
3. Please remember to RESET your class variables declared in class MagicDictionary, as static/class variables are persisted across multiple test cases. Please see herefor more details.

---

实现一个带有buildDict, 以及 search方法的魔法字典。

对于buildDict方法，你将被给定一串不重复的单词来构建一个字典。

对于search方法，你将被给定一个单词，并且判定能否只将这个单词中一个字母换成另一个字母，使得所形成的新单词存在于你构建的字典中。

示例 1:

Input: buildDict(["hello", "leetcode"]), Output: Null
Input: search("hello"), Output: False
Input: search("hhllo"), Output: True
Input: search("hell"), Output: False
Input: search("leetcoded"), Output: False

注意:

1. 你可以假设所有输入都是小写字母 a-z。
2. 为了便于竞赛，测试所用的数据量很小。你可以在竞赛结束后，考虑更高效的算法。
3. 请记住重置MagicDictionary类中声明的类变量，因为静态/类变量会在多个测试用例中保留。 请参阅这里了解更多详情。

---

8ms

class MagicDictionary {
    var map = [Int: Set<String>]()
    /** Initialize your data structure here. */
    init() {

    }

    /** Build a dictionary through a list of words */
    func buildDict(_ dict: [String]) {
        map.removeAll()
        for str in dict {
            var sets = map[str.count, default: Set<String>()]
            sets.insert(str)
            map[str.count] = sets
        }
    }

    /** Returns if there is any word in the trie that equals to the given word after modifying exactly one character */
    func search(_ word: String) -> Bool {
        let sets = map[word.count, default: Set<String>()]
        let srcChars = Array(word)
        for str in sets {
            var diffct = 0
            let curChars = Array(str)
            for i in 0..<word.count {
                if srcChars[i] != curChars[i] { diffct += 1 }
                if diffct > 1 { break }
            }
            if diffct == 1 { return true }
        }
        return false
    }
}

/**
 * Your MagicDictionary object will be instantiated and called as such:
 * let obj = MagicDictionary()
 * obj.buildDict(dict)
 * let ret_2: Bool = obj.search(word)
 */

---

16ms

class MagicDictionary {
    private var dictionary : [Int : [String]] = [:]
    /** Initialize your data structure here. */
    init() {
        
    }
    
    /** Build a dictionary through a list of words */
    func buildDict(_ dict: [String]) {
        for str in dict{
            if dictionary[str.count] == nil{
                dictionary[str.count] = [str]
            }else{
                dictionary[str.count]!.append(str)
            }
            
        }
    }
    
    /** Returns if there is any word in the trie that equals to the given word after modifying exactly one character */
    func search(_ word: String) -> Bool {
        guard let words = dictionary[word.count] else{
            return false
        }
        
        for str in words{
            if isOneDifference(Array(str), Array(word)){
                return true
            }
        }
        return false
    }
    
    private func isOneDifference(_ first : [Character], _ second : [Character])->Bool{
        guard first.count == second.count else{
            return false
        }
        var movingIndex : Int = 0
        var diffCount : Int = 0
        
        while movingIndex < first.count{
            if first[movingIndex] != second[movingIndex]{
                if diffCount == 1{
                    return false
                }
                diffCount += 1
            }
            movingIndex += 1
        }
        
        return diffCount == 1
    }
}

---

20ms

class MagicDictionary {

    
    var trie: Trie
    
    /** Initialize your data structure here. */
    init() {
        self.trie = Trie()
    }
    
    /** Build a dictionary through a list of words */
    func buildDict(_ dict: [String]) {
        dict.forEach{ self.trie.insert($0) }

    }
    
    /** Returns if there is any word in the trie that equals to the given word after modifying exactly one character */
    func search(_ word: String) -> Bool {
      
        let wordArray = word.map{ String($0) }
                
        return self.trie.search(wordArray, errorCount: 0)        
    }    
}

class Trie {
    
    var roots: [String: Node]
    
    init() {
        self.roots = [String: Node]()
    }
    
    func search(_ word: [String], errorCount: Int) -> Bool {
        
        guard let first = word.first else { return false }
        
        var result = false        
        self.roots.forEach{ (key, value) in
                          
                           let newResult = search(word, at: value, errorCount: errorCount)
                           result = result || newResult
                           
                          }
        
        return result
    }
    
    func search(_ word: [String], at node: Node, errorCount: Int) -> Bool {
        
        guard let first = word.first else { return errorCount == 1 }
        
        if first != node.char && errorCount >= 1 { return false }
        
        var errorCount = errorCount
        if first != node.char { errorCount += 1 }
        
        if word.count == 1 && errorCount == 1 && node.isWord { return true }
        
        var newWord = word
        newWord.removeFirst()
        
        if let next = newWord.first {            
            let allChilds = node.childs
            var result = false
            allChilds.forEach{ (key, value) in
                              let newResult = search(newWord, at: value, errorCount: errorCount)
                              result = result || newResult
                }
                
                return result
        }        
        return false        
    } 
    
    
    func insert(_ word: String) {        
        var wordArray = word.map{ String($0) }        
        guard let first = wordArray.first else { return }
        var node = self.roots[first] ?? Node(first)   
        self.roots[first] = insert(wordArray, at: node)        
    }
    
    
    func insert(_ word: [String], at node: Node) -> Node {
        
        guard let first = word.first else { return node }
        guard first == node.char else { return node }

        if word.count == 1 {
            node.isWord = true
            return node
        }
        
        var newWord = word
        newWord.removeFirst()
        
        let next = newWord.first!
                
        let child = node.childs[next] ?? Node(next) 
        
        let newChild = insert(newWord, at: child)
        
        node.childs[next] = newChild
        
        return node
    }
    
}

class Node {
    
    let char: String
    var isWord = false
    var childs: [String: Node]
    
    init(_ char: String) {
        
        self.char = char
        self.childs = [String: Node]()
    }    
}

---

Runtime: 72 ms

Memory Usage: 20 MB

class MagicDictionary {
    var s:Set<String>

    /** Initialize your data structure here. */
    init() {
        s = Set<String>()
    }
    
    /** Build a dictionary through a list of words */
    func buildDict(_ dict: [String]) {
        for word in dict
        {
            s.insert(word)
        }      
    }
    
    /** Returns if there is any word in the trie that equals to the given word after modifying exactly one character */
    func search(_ word: String) -> Bool {  
        var word = word
        var arr:[Character] = Array(word)
        for i in 0..<arr.count
        {
            var t:Character = arr[i]
            for c in 97...122
            {
                var char = c.ASCII
                if char == t {continue}
                arr[i] = char
                word = String(arr)
                if s.contains(word)
                {
                    return true
                }
            }          
            arr[i] = t
        }
        return false      
    }
}

//Int扩展
extension Int
{
    //Int转Character,ASCII值(定义大写为字符值)
    var ASCII:Character 
    {
        get {return Character(UnicodeScalar(self)!)}
    }
}
/**
 * Your MagicDictionary object will be instantiated and called as such:
 * let obj = MagicDictionary()
 * obj.buildDict(dict)
 * let ret_2: Bool = obj.search(word)
 */