Merge pull request ByteByteGoHq#38 from ongshunping/cpp-solutions-tries

Add C++ solutions for Chapter 12 (Tries)

Author: Destiny-02

cpp/Tries/design_a_trie.cpp

@@ -0,0 +1,71 @@
+#include <unordered_map>
+#include <string>
+
+class TrieNode {
+public:
+    std::unordered_map<char, TrieNode*> children;
+    bool isWord;
+    TrieNode() : isWord(false) {}
+    ~TrieNode() {
+        for (auto& pair : children) {
+            delete pair.second;
+        }
+    }
+};
+
+class Trie {
+public:
+    Trie() {
+        root = new TrieNode();
+    }
+
+    ~Trie() {
+        delete root;
+    }
+
+    void insert(std::string word) {
+        TrieNode* node = root;
+        for (char c : word) {
+            // For each character in the word, if it's not a child of
+            // the current node, create a new TrieNode for that 
+            // character.
+            if (node->children.find(c) == node->children.end()) {
+                node->children[c] = new TrieNode();
+            }
+            node = node->children[c];
+        }
+        // Mark the last node as the end of a word.
+        node->isWord = true;
+    }
+
+    bool search(std::string word) {
+        TrieNode* node = root;
+        for (char c : word) {
+            // For each character in the word, if it's not a child of
+            // the current node, the word doesn't exist in the Trie.
+            if (node->children.find(c) == node->children.end()) {
+                return false;
+            }
+            node = node->children[c];
+        }
+        // Return whether the current node is marked as the end of the
+        // word.
+        return node->isWord;
+    }
+
+    bool hasPrefix(std::string prefix) {
+        TrieNode* node = root;
+        for (char c : prefix) {
+            if (node->children.find(c) == node->children.end()) {
+                return false;
+            }
+            node = node->children[c];
+        }
+        // Once we've traversed the nodes corresponding to each
+        // character in the prefix, return True.
+        return true;
+    }
+
+private:
+    TrieNode* root;
+};

cpp/Tries/find_all_words_on_a_board.cpp

@@ -0,0 +1,75 @@
+#include <unordered_map>
+#include <vector>
+#include <string>
+
+class TrieNode {
+public:
+    std::unordered_map<char, TrieNode*> children;
+    std::string word;
+    TrieNode() : word("") {}
+    ~TrieNode() {
+        for (auto& pair : children) {
+            delete pair.second;
+        }
+    }
+};
+
+std::vector<std::string> findAllWordsOnABoard(std::vector<std::vector<char>>& board, std::vector<std::string>& words) {
+    TrieNode* root = new TrieNode();
+    // Insert every word into the trie.
+    for (std::string& word : words) {
+        TrieNode* node = root;
+        for (char c : word) {
+            if (node->children.find(c) == node->children.end()) {
+                node->children[c] = new TrieNode();
+            }
+            node = node->children[c];
+        }
+        node->word = word;
+    }
+    std::vector<std::string> res;
+    // Start a DFS call from each cell of the board that contains a
+    // child of the root node, which represents the first letter of a
+    // word in the trie.
+    int rows = board.size();
+    int cols = board[0].size();
+    for (int r = 0; r < rows; r++) {
+        for (int c = 0; c < cols; c++) {
+            if (root->children.find(board[r][c]) != root->children.end()) {
+                dfs(board, r, c, root->children[board[r][c]], res);
+            }
+        }
+    }
+    delete root;
+    return res;
+}
+
+void dfs(std::vector<std::vector<char>>& board, int r, int c, TrieNode* node, std::vector<std::string>& res) {
+    // If the current node represents the end of a word, add the word to
+    // the result.
+    if (!node->word.empty()) {
+        res.push_back(node->word);
+        // Ensure the current word is only added once.
+        node->word = "";
+    }
+    char temp = board[r][c];
+    // Mark the current cell as visited.
+    board[r][c] = '#';
+    // Explore all adjacent cells that correspond with a child of the 
+    // current TrieNode.
+    std::vector<std::pair<int, int>> dirs = { {-1, 0}, {1, 0}, {0, -1}, {0, 1} };
+    for (auto& dir : dirs) {
+        int next_r = r + dir.first;
+        int next_c = c + dir.second;
+        if (isWithinBounds(next_r, next_c, board) &&
+            node->children.find(board[next_r][next_c]) != node->children.end()) {
+            dfs(board, next_r, next_c, node->children[board[next_r][next_c]], res);
+        }
+    }
+    // Backtrack by reverting the cell back to its original character.
+    board[r][c] = temp;
+}
+
+bool isWithinBounds(int r, int c, std::vector<std::vector<char>>& board) {
+    return r >= 0 && r < board.size() && c >= 0 && c < board[0].size();
+}

cpp/Tries/insert_and_search_words_with_wildcards.cpp

@@ -0,0 +1,68 @@
+#include <unordered_map>
+#include <string>
+
+class TrieNode {
+public:
+    std::unordered_map<char, TrieNode*> children;
+    bool isWord;
+    TrieNode() : isWord(false) {}
+    ~TrieNode() {
+        for (auto& pair : children) {
+            delete pair.second;
+        }
+    }
+};
+
+class InsertAndSearchWordsWithWildcards {
+public:
+    InsertAndSearchWordsWithWildcards() {
+        root = new TrieNode();
+    }
+
+    ~InsertAndSearchWordsWithWildcards() {
+        delete root;
+    }
+
+    void insert(std::string word) {
+        TrieNode* node = root;
+        for (char c : word) {
+            if (node->children.find(c) == node->children.end()) {
+                node->children[c] = new TrieNode();
+            }
+            node = node->children[c];
+        }
+        node->isWord = true;
+    }
+
+    bool search(std::string word) {
+        // Start searching from the root of the trie.
+        return searchHelper(0, word, root);
+    }
+
+private:
+    TrieNode* root;
+    
+    bool searchHelper(int wordIndex, std::string word, TrieNode* node) {
+        for (int i = wordIndex; i < word.length(); i++) {
+            char c = word[i];
+            // If a wildcard character is encountered, recursively
+            // search for the rest of the word from each child node. 
+            if (c == '.') {
+                for (auto& pair : node->children) {
+                    // If a match is found, return true.
+                    if (searchHelper(i + 1, word, pair.second)) {
+                        return true;
+                    }
+                }
+                return false;
+            } else if (node->children.find(c) != node->children.end()) {
+                node = node->children[c];
+            } else {
+                return false;
+            }
+        }
+        // After processing the last character, return true if we've
+        // reached the end of a word. 
+        return node->isWord;
+    }
+};