字典树

208. 实现 Trie (前缀树)

class TrieNode {
public:
    TrieNode() {
        isend = false;
        children.clear();
    }

    bool isend;
    unordered_map<char, TrieNode*> children;
};

class Trie {
private:
    TrieNode* root;

public:
    Trie() {
        root = new TrieNode();
    }
    
    void insert(string word) {
        TrieNode* cur = root;
        for (int i = 0; i < word.size(); i++) {
            if (cur -> children.count(word[i]) == 0) {
                cur -> children[word[i]] = new TrieNode();
            }
            cur = cur -> children[word[i]];
        }
        cur -> isend = true;
    }
    
    bool search(string word) {
        TrieNode* cur = root;
        for (int i = 0; i < word.size(); i++) {
            if (cur -> children.count(word[i]) == 0) {
                return false;
            }
            cur = cur -> children[word[i]];
        }
        return cur -> isend;
    }
    
    bool startsWith(string prefix) {
        TrieNode* cur = root;
        for (int i = 0; i < prefix.size(); i++) {
            if (cur -> children.count(prefix[i]) == 0) {
                return false;
            }
            cur = cur -> children[prefix[i]];
        }
        return true;
    }
};

/**
 * Your Trie object will be instantiated and called as such:
 * Trie* obj = new Trie();
 * obj->insert(word);
 * bool param_2 = obj->search(word);
 * bool param_3 = obj->startsWith(prefix);
 */

211. 添加与搜索单词 - 数据结构设计

class TireNode {
public:
    bool isend;
    unordered_map<char, TireNode*> child;
    TireNode() {
        child.clear();
        isend = false;
    }
};

class WordDictionary {
private:
    TireNode * root;
public:
    WordDictionary() {
        root = new TireNode();
    }
    
    void addWord(string word) {
        TireNode * cur = root;
        for (int i = 0; i < word.size(); i++) {
            if (cur -> child.count(word[i]) == 0) {
                cur -> child[word[i]] = new TireNode();
            }
            cur = cur -> child[word[i]];
        }
        cur -> isend = true;
    }
    
    bool search(string word) {
       return dfs(word, root, 0);
    }

    bool dfs(string &word, TireNode* node, int index) {
        
        TireNode * cur = node;
        for (int i = index; i < word.size(); i++) {
            if (word[i] == '.') {
                for (auto &child: cur -> child) {
                    if (dfs(word, child.second, i + 1))
                        return true;
                }
                return false;
            }
            else {
                if (cur -> child.count(word[i]) == 0) {
                    return false;
                }
                cur = cur -> child[word[i]];
            }
        }
        return cur -> isend;
    }
};

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

212. 单词搜索 II

class TireNode {
public:
    unordered_map<char, TireNode*> child;
    string str;
    TireNode() {
        child.clear();
        str = "";
    }
    void insert(string word) {
        TireNode* cur = this;
        for (int i = 0; i < word.size(); i++) {
            if (cur -> child.count(word[i]) == 0) {
                cur -> child[word[i]] = new TireNode();
            }
            cur = cur -> child[word[i]];
        }
        cur -> str = word;
    }
};

class Solution {
public:
    int dir[4][2] = {0, 1, 1, 0, 0, -1, -1, 0};
    void dfs(vector<vector<char>>& board,  int x, int y, TireNode* node, unordered_set<string> &result_set, vector<vector<bool>>& visited) {
        
        if (node -> child.count(board[x][y]) == 0) 
            return;

        if (node -> child.count(board[x][y]) > 0) {
            node = node -> child[board[x][y]];
            if (node -> str != "") {
                result_set.insert(node -> str);
            }
            
            for (int i = 0; i < 4; i++) {
                int newX = x + dir[i][0];
                int newY = y + dir[i][1];
                if (newX < 0 || newY < 0 || newX >= board.size() || newY >= board[0].size()) {
                    continue;
                }
                if (visited[newX][newY] == false) {
                    visited[newX][newY] = true;
                    dfs(board, newX, newY, node, result_set, visited);
                    visited[newX][newY] = false;
                }
                
            }
            
        }
    }   

    vector<string> findWords(vector<vector<char>>& board, vector<string>& words) {
            TireNode * root = new TireNode();
            for (int i = 0; i < words.size(); i++) {
                root -> insert(words[i]);
            }
            vector<string> result;
            unordered_set<string> result_set;
            vector<vector<bool>> visited(board.size(), vector<bool>(board[0].size(), false));
            for (int i = 0; i < board.size(); i++) {
                for (int j = 0; j < board[0].size(); j++){
                    visited[i][j] = true;
                    
                    dfs(board, i, j, root, result_set, visited);
                    visited[i][j] = false;
                }
            }

            for (auto &word: result_set) {
                result.push_back(word);
            }
            return result;

    }
};