[Swift]LeetCode211. 添加与搜索单词

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

Design a data structure that supports the following two operations:

void addWord(word)
bool search(word)

search(word) can search a literal word or a regular expression string containing only letters a-z or .. A . means it can represent any one letter.

Example:

addWord("bad")
addWord("dad")
addWord("mad")
search("pad") -> false
search("bad") -> true
search(".ad") -> true
search("b..") -> true

Note:
You may assume that all words are consist of lowercase letters a-z.

---

设计一个支持以下两种操作的数据结构：

void addWord(word)
bool search(word)

search(word) 可以搜索文字或正则表达式字符串，字符串只包含字母 . 或 a-z 。 . 可以表示任何一个字母。

示例:

addWord("bad")
addWord("dad")
addWord("mad")
search("pad") -> false
search("bad") -> true
search(".ad") -> true
search("b..") -> true

说明:

你可以假设所有单词都是由小写字母 a-z 组成的。

---

612ms

class TrieNode {
    var children: [Character: TrieNode]
    var isEnd: Bool
    
    init() {
        children = [:]
        isEnd = false
    }
}

class WordDictionary {
    
    private var root: TrieNode
    /** Initialize your data structure here. */
    init() {
        root = TrieNode()
    }
    
    /** Adds a word into the data structure. */
    func addWord(_ word: String) {
        var node = self.root
        
        for c in Array(word) {
            if let next = node.children[c] {
                node = next
            } else {
                let newNode = TrieNode()
                node.children[c] = newNode
                node = newNode
            }
        }
        node.isEnd = true
    }
    
    /** Returns if the word is in the data structure. A word could contain the dot character '.' to represent any one letter. */
    func search(_ word: String) -> Bool {
        return self.match(Array(word), 0, self.root)
    }
    
    private func match(_ chars: [Character], _ i :Int, _ node: TrieNode) -> Bool {
        // if we reached the end
        if i == chars.count {
            return node.isEnd
        }
        let c = chars[i]
        if c != "." {
            guard let next = node.children[c] else { return false }
            return self.match(chars, i + 1, next)
        } else {
            for next in node.children.values {
                if self.match(chars, i + 1, next) {
                    return true
                }
            }
        }
        
        return false
    }
}

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

---

620ms

class WordDictionary {
    var trie = Trie()

    /** Initialize your data structure here. */
    init() {

    }
    
    /** Adds a word into the data structure. */
    func addWord(_ word: String) {
      trie.add(word: word)
    }
    
    /** Returns if the word is in the data structure. A word could contain the dot character '.' to represent any one letter. */
    func search(_ word: String) -> Bool {
      return trie.search(word:word)
    }
}

class TrieNode {
  var children: [Character: TrieNode]
  var isEnd: Bool

  init() {
    self.children = [Character: TrieNode]()
    self.isEnd = false
  }
}


class Trie {
  var root: TrieNode

  init() {
    root = TrieNode()
  }

  func add(word: String) {
    var node = root

    for char in word {
      if node.children[char] == nil {
        node.children[char] = TrieNode()
      }

      node = node.children[char]!
    }

    node.isEnd = true
  }
  
  func search(word:String) -> Bool {
    return dfsSearch(word: word, index: 0, node: root)
  }
  
  fileprivate func dfsSearch(word: String, index: Int, node: TrieNode) -> Bool {
    if index == word.count {
      return node.isEnd
    }
    
    let char = Array(word)[index]
    
    if char != "." {
      guard let nextNode = node.children[char] else {
        return false
      }
      
      return dfsSearch(word: word, index: index + 1, node: nextNode)
    } else{
      for key in node.children.keys {
        if dfsSearch(word: word, index: index + 1, node: node.children[key]!) {
          return true
        }
      }
      
      return false
    }
  }
}
/**
 * Your WordDictionary object will be instantiated and called as such:
 * let obj = WordDictionary()
 * obj.addWord(word)
 * let ret_2: Bool = obj.search(word)
 */
 

---

644ms

class TrieNode {
    var children = [Character : TrieNode]()
    var isEnd = false
}


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 currentNode: TrieNode? = root
        for c in word {
            if let nextNode = currentNode?.children[c] {
                currentNode = nextNode
            } else {
                let newNode = TrieNode()
                
                currentNode?.children[c] = newNode
                currentNode = newNode
            }
        }
        
        currentNode?.isEnd = true
    }
    
    /** Returns if the word is in the trie. */
    func search(_ word: String) -> Bool {
        return searchNode(root, word: word, index: word.startIndex)
    }
    
    func searchNode(_ node: TrieNode, word: String, index: String.Index) -> Bool {
        if index == word.endIndex {
            return node.isEnd
        }
        
        var currentNode: TrieNode? = root
        let char = word[index]
        if char == "." {
            for (_, n) in node.children {
                if searchNode(n, word: word, index: word.index(after: index)) {
                    return true
                }
            }
            
            return false
        } else {
            guard let nextNode = node.children[char] else {
                return false
            }

            return searchNode(nextNode, word: word, index: word.index(after: index))
        }
    }
    
    /** Returns if there is any word in the trie that starts with the given prefix. */
    func startsWith(_ prefix: String) -> Bool {
      var currentNode: TrieNode? = root
        for c in prefix {
            guard let nextNode = currentNode?.children[c] else {
                return false
            }
            
            currentNode = nextNode
        }
        
        return true
    }
}


class WordDictionary {
    private let trie = Trie()
    
    
    /** Initialize your data structure here. */
    init() {
        
    }
    
    /** Adds a word into the data structure. */
    func addWord(_ word: String) {
        trie.insert(word)
    }
    
    /** Returns if the word is in the data structure. A word could contain the dot character '.' to represent any one letter. */
    func search(_ word: String) -> Bool {
        return trie.search(word)
    }
}

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

---

756ms

class WordDictionary {
    var trie = Trie()
    /** Initialize your data structure here. */
    init() {
        
    }
    
    /** Adds a word into the data structure. */
    func addWord(_ word: String) {
        trie.insert(word)
    }
    
    /** Returns if the word is in the data structure. A word could contain the dot character '.' to represent any one letter. */
    func search(_ word: String) -> Bool {
        return trie.search(word, 0, trie.root)
    }
}

class TrieNode {
    var isWord = false
    var next = [Character: TrieNode]()
    init(_ b: Bool = false) {
        isWord = b
    }
}

class Trie {
    var root = TrieNode()
    func insert(_ word: String) {
        var cur = root
        for c in word {
            if cur.next[c] == nil {
                cur.next[c] = TrieNode()
            }
            cur = cur.next[c]!
        }
        cur.isWord = true
    }
    
    func search(_ word: String, _ idx: Int, _ node: TrieNode) -> Bool {
        var cur = node
        var chars = Array(word)
        for i in idx..<chars.count {
            if let n = cur.next[chars[i]] {
                cur = n
            } else if chars[i] != "." {
                return false
            } else {
                for n in cur.next.values {
                    if search(word, i+1, n) {
                        return true
                    }
                }
                return false
            }
        }
        return cur.isWord
    }
}

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

---

764ms

class Trie {
    var char: Character
    var children: [Character :Trie]
    
    init(_ char: Character) {
        self.char = char
        self.children = [:]
    }
}

class WordDictionary {
    var root: Trie
    /** Initialize your data structure here. */
    init() {
        self.root = Trie(Character(".")) 
    }
    
    /** Adds a word into the data structure. */
    func addWord(_ word: String) {
        var temp = root
        for char in word {
            if let child = temp.children[char] {
                temp = child
            } else {
                let newNode = Trie(char)
                temp.children[char] = newNode
                temp = newNode
            }
        }
        let newNode = Trie("$")
        temp.children["$"] = newNode
        temp = newNode
    }
    
    /** Returns if the word is in the data structure. A word could contain the dot character '.' to represent any one letter. */
    func search(_ word: String) -> Bool {
        return searchInternal(word, self.root)
    }
    
    private func searchInternal(_ word: String, _ node:Trie) -> Bool {
        // print("Searching word : (word)")
        if word.isEmpty {
            // print("Valid!!!!!!")
            if let child = node.children["$"] {
                return true
            } else {
                return false
            }
        }
        let firstChar = word[word.index(word.startIndex, offsetBy: 0)]
        let trimmedWord = String(word[word.index(word.startIndex, offsetBy: 1)..<word.endIndex])
        if firstChar == "." {
            for child in node.children {
                let isValidNode = self.searchInternal(trimmedWord, child.value)
                if isValidNode {
                    return true
                    break
                }
            }
        } else {
            if let child = node.children[firstChar] {
                return self.searchInternal(trimmedWord, child)
            } else {
                // print("not valid1")
                return false
            }
        }
        // print("not valid0")
        return false
    }
}

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