LeetCode 211. Design Add and Search Words Data Structure

原题链接在这里：https://leetcode.com/problems/design-add-and-search-words-data-structure/

题目：

Design a data structure that supports adding new words and finding if a string matches any previously added string.

Implement the WordDictionary class:

• WordDictionary() Initializes the object.
• void addWord(word) Adds word to the data structure, it can be matched later.
• bool search(word) Returns true if there is any string in the data structure that matches word or false otherwise. word may contain dots '.' where dots can be matched with any letter.

Example:

Input
["WordDictionary","addWord","addWord","addWord","search","search","search","search"]
[[],["bad"],["dad"],["mad"],["pad"],["bad"],[".ad"],["b.."]]
Output
[null,null,null,null,false,true,true,true]

Explanation
WordDictionary wordDictionary = new WordDictionary();
wordDictionary.addWord("bad");
wordDictionary.addWord("dad");
wordDictionary.addWord("mad");
wordDictionary.search("pad"); // return False
wordDictionary.search("bad"); // return True
wordDictionary.search(".ad"); // return True
wordDictionary.search("b.."); // return True 

Constraints:

• 1 <= word.length <= 500
• word in addWord consists lower-case English letters.
• word in search consist of  '.' or lower-case English letters.
• At most 50000 calls will be made to addWord and search.

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

题解：

查找词用到Trie树.

addword和Implement Trie (Prefix Tree)相同. search时利用dfs, 终止条件有两种.

一种是string 还没扫完, 已经走到了null节点, return false.

另一种扫完了string, 要看是否到了Trie树的叶子节点. 

dfs过程分两种情况，一种情况是当前char 是'.', 此时应该跳过这个char, 同时对剩余string和tn.nexts 的所有储存的节点继续迭代，若有一个正好走到叶子节点, 就返回ture; 若没有一个正好走到叶子节点，就return false.

另一种情况是当前char不是'.', 就继续用root.nexts[c-'a'] 和 word, i+1 index做dfs.

Time Complexity: addWord, O(n). search, O(26^n), n是string 长度. worst case每一个路径都要扫.

Space: (m*n). m is number of words added.

AC Java:

class WordDictionary {
    TrieNode root;

    /** Initialize your data structure here. */
    public WordDictionary() {
        root = new TrieNode();
    }

    /** Adds a word into the data structure. */
    public void addWord(String word) {
        TrieNode p = root;
        for(char c : word.toCharArray()){
            if(p.nexts[c - 'a'] == null){
                p.nexts[c - 'a'] = new TrieNode();
            }

            p = p.nexts[c - 'a'];
        }

        p.val = word;
    }

    /** Returns if the word is in the data structure. A word could contain the dot character '.' to represent any one letter. */
    public boolean search(String word) {
        if(word == null || word.length() == 0){
            return false;
        }

        return searchWord(word, 0, root);
    }

    private boolean searchWord(String word, int index, TrieNode p){
        if(p == null){
            return false;
        }

        if(index == word.length()){
            return p.val != null;
        }

        if(word.charAt(index) == '.'){
            for(TrieNode next : p.nexts){
                if(searchWord(word, index + 1, next)){
                    return true;
                }
            }

        }else{
            return searchWord(word, index + 1, p.nexts[word.charAt(index) - 'a']);
        }

        return false;
    }
}

class TrieNode{
    String val;
    TrieNode [] nexts;

    public TrieNode(){
        nexts = new TrieNode[26];
    }
}

/**
 * Your WordDictionary object will be instantiated and called as such:
 * WordDictionary obj = new WordDictionary();
 * obj.addWord(word);
 * boolean param_2 = obj.search(word);
 */

AC Python:

class WordDictionary:

    def __init__(self):
        """
        Initialize your data structure here.
        """
        self.root = TrieNode()
        
    def addWord(self, word: str) -> None:
        p = self.root
        for c in word:
            if c not in p.next:
                p.next[c] = TrieNode()
            p = p.next[c]
        p.val = word

    def search(self, word: str) -> bool:
        if not word:
            return False
        
        p = self.root
        return self.dfs(word, 0, p)
    
    def dfs(self, word, ind, p):
        if ind == len(word):
            if p.val:
                return True
            else:
                return False
        
        if word[ind] == ".":
            return any([self.dfs(word, ind + 1, can) for can in p.next.values()])
            
        else:
            if word[ind] not in p.next:
                return False
            return self.dfs(word, ind + 1, p.next[word[ind]])

class TrieNode:
    def __init__(self):
        self.val = ""
        self.next = {}