（Trie树）leetcode208: Implement Trie，79：Word Search，DFS与BFS（python实现），212：Word Search2

前缀树：查找字符串或其前缀。

一）数组实现，每个结点初始化有26个子结点，插入结点时，将该字母对应索引上创建结点。

class TrieNode{
public:
    TrieNode* child[26];
    bool isWord;
    //构造函数初始化列表
    TrieNode() : isWord(false){
        for(auto& a: child)
            a = nullptr;
    }
    ~TrieNode(){
        delete[] child;
    }
};

class Trie {
private:
    TrieNode* root;
    
public:
    /** Initialize your data structure here. */
    Trie() {
        root = new TrieNode();
    }
    
    /** Inserts a word into the trie. */
    void insert(string word) {
        TrieNode* p = root;
        for(char a: word){
            int i = a - 'a';
            if(!p->child[i])
                //若某一字母对应索引的结点不存在
                p->child[i] = new TrieNode();
            p = p->child[i];
        }
        p->isWord = true;
    }
    
    /** Returns if the word is in the trie. */
    bool search(string word) {
        TrieNode* p = root;
        for(char a:word){
            int i = a - 'a';
            if(!p->child[i])
                return false;
            p = p->child[i];
        }
        return p->isWord;
    }
    
    /** Returns if there is any word in the trie that starts with the given prefix. */
    bool startsWith(string prefix) {
        TrieNode* p = root;
        for(char a: prefix){
            int i = a - 'a';
            if(!p->child[i])
                return false;
            p = p->child[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);
 */

class TrieNode{
public:
    vector<TrieNode*> child;
    bool isWord;
    //构造函数初始化列表
    TrieNode() : isWord(false), child(26, nullptr){}
    ~TrieNode(){
        for(auto& c:child)
            delete c;
    }
};

class Trie {
private:
    TrieNode* root;
    
public:
    /** Initialize your data structure here. */
    Trie() {
        root = new TrieNode();
    }
    
    /** Inserts a word into the trie. */
    void insert(string word) {
        TrieNode* p = root;
        for(char a: word){
            int i = a - 'a';
            if(!p->child[i])
                //若某一字母对应索引的结点不存在
                p->child[i] = new TrieNode();
            p = p->child[i];
        }
        p->isWord = true;
    }
    
    /** Returns if the word is in the trie. */
    bool search(string word) {
        TrieNode* p = root;
        for(char a:word){
            int i = a - 'a';
            if(!p->child[i])
                return false;
            p = p->child[i];
        }
        return p->isWord;
    }
    
    /** Returns if there is any word in the trie that starts with the given prefix. */
    bool startsWith(string prefix) {
        TrieNode* p = root;
        for(char a: prefix){
            int i = a - 'a';
            if(!p->child[i])
                return false;
            p = p->child[i];
        }
        return true;
    }
};

/**
二）vector容器实现，注意下构造函数和析构函数与数组的写法有差异。
 * 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);
 */

注意：同一个字符不能使用多次，即不能往回走。

思路：深度优先搜索，枚举每一个格子，将它作为根结点，来向上，向左，向右，向下寻找和word相同的字符。

 伪代码：

class Solution {
private:
    int w;
    int h;
    
public:
    bool exist(vector<vector<char>>& board, string word) {
        if(board.size()==0) return false;
        h = board.size();
        w = board[0].size();
        for(int i=0; i<w; i++){
            for(int j=0; j<h; j++){
                if(search(board, word, 0, i, j))
                    return true;
            }
        }
        return false;
    }
    
    bool search(vector<vector<char>>& board, const string& word, int d, int x, int y){
        if(x<0 || x==w ||y<0 || y==h || word[d]!=board[y][x])
            return false;
        //found the last char of the word
        if(d == word.length()-1)
            return true;
        //走过之后标记为不能走
        char cur = board[y][x];
        board[y][x]=0;
        bool found = search(board, word, d+1, x+1, y) 
            || search(board, word, d+1, x, y+1)
            || search(board, word, d+1, x-1, y)
            || search(board, word, d+1, x, y-1);
        //递归结束后再标记回来
        board[y][x] = cur;
        return found;
    }
};

 

BFS：python实现，用队列先进先出实现。

#字典
graph ={
    "A":["B","C"],
    "B":["A","C","D"],
    "C":["A","B","D","E"],
    "D":["B","C","E","F"],
    "E":["C", "D"],
    "F":["D"]
}

def BFS(graph, s):  #s结点
    queue = []  #数组来实现队列
    queue.append(s)
    seen = set()  #集合
    seen.add(s)
    while(len(queue)):
        vertex = queue.pop(0)
        nodes = graph[vertex]
        for w in nodes:
            if w not in seen:
                queue.append(w)
                seen.add(w)
        print(vertex)

DFS: 用栈的后进先出来实现。

def DFS(graph, s):  #s结点
    stack = []  #数组来实现栈
    stack.append(s)
    seen = set()
    seen.add(s)
    while(len(stack)):
        vertex = stack.pop()
        nodes = graph[vertex]
        for w in nodes:
            if w not in seen:
                stack.append(w)
                seen.add(w)
        print(vertex)

从A走到任一点的最短路径可以用这个图打印出来了。用映射表格来记录每一个结点的前一个结点。

问：从A到E的最短路径是哪一条？

答：从点E出发，它的前一个结点是C，再找到A，结束。

映射可以用字典来写。

def BFS(graph, s):  #s结点
    queue = []  
    queue.append(s)
    seen = set()
    seen.add(s)
    parent = {s: None} #字典来实现映射
    
    while(len(queue)):
        vertex = queue.pop(0)
        nodes = graph[vertex]
        for w in nodes:
            if w not in seen:
                queue.append(w)
                seen.add(w)
                parent[w] = vertex
        print(vertex)
    return parent

这道题是真心难，它用到了Trie树中的insert函数和深度优先搜索。先把words里的单词插入到Trie树中，其中Trie树里有个string变量叫str，用来存储当前是一个单词的字符串。然后使用两层for循环，在board里搜索Trie树的每个结点。

class Solution {
public:
    struct TrieNode{
        TrieNode* child[26];
        string str;
        TrieNode(): str(""){
            for(auto& a: child)
                a = nullptr;
        }
        ~TrieNode(){
            delete[] child;
        }
    };
    
    struct Trie{
        TrieNode* root = new TrieNode();
        void insert(string word){
            TrieNode* p = root;
            for(char a:word){
                int i = a -'a';
                if(!p->child[i])
                    p->child[i] = new TrieNode();
                p = p->child[i];
            }
            p->str = word;
        }
    };

    vector<string> findWords(vector<vector<char>>& board, vector<string>& words) {
        vector<string> res;
        int n = board.size();
        int m = board[0].size();
        if(n==0 || m==0 || words.empty()) return res;
        //记录是否访问过
        vector<vector<bool>> visit(board.size(), vector<bool>(board[0].size(), false));
        Trie T;
        for(auto& a:words)
            T.insert(a);
        for(int i=0; i<n; ++i){
            for(int j=0; j<m; ++j){
                if(T.root->child[board[i][j]-'a'])
                    search(board, T.root->child[board[i][j]-'a'], i, j, visit, res);
            }
        }
        return res;
    }
    
    void search(vector<vector<char>>& board, TrieNode* p, int i, int j, vector<vector<bool>>& visit, vector<string>& res){
        if(!p->str.empty()){
            res.push_back(p->str);
            p->str.clear();
        }
        int d[][2]={{-1,0},{1,0},{0,-1},{0,1}};
        visit[i][j] = true;
        for(auto& a:d){
            int nx = a[0]+i, ny = a[1]+j;
            if(nx>=0 && nx<board.size() && ny>=0 && ny<board[0].size() && !visit[nx][ny] && p->child[board[nx][ny]-'a'])
                search(board, p->child[board[nx][ny]-'a'], nx, ny, visit, res);
        }
        
        visit[i][j] = false;
    }
};

 

class Solution {
public:
    /*
     * @param words: a set of words without duplicates
     * @return: all word squares
     */
    struct TrieNode{
        vector<TrieNode*> children;
        vector<int> index;
        TrieNode():children(26, nullptr){}
    };
    
    TrieNode* buildTrie(vector<string>& words){
        TrieNode* root = new TrieNode();
        for(int i=0; i<words.size(); ++i){
            TrieNode* t = root;
            //对于每一个单词遍历
            for(int j=0; j<words[i].size(); ++j){
                if(!t->children[words[i][j]-'a'])
                    t->children[words[i][j]-'a'] = new TrieNode();
                t = t->children[words[i][j]-'a'];
                t->index.push_back(i);   //储存当前前缀的单词所在words中的索引
            }
        }
        return root;
    }
    
    vector<vector<string>> wordSquares(vector<string> &words) {
        // write your code here
        vector<vector<string>> res;
        if(words.size()==0) return res;
        TrieNode* root = buildTrie(words);
        vector<string> out(words[0].size());
        for(auto word: words){
            out[0] = word;
            dfs(words, root, 1, out, res);
        }
        return res;
    }
    
    void dfs(vector<string> &words, TrieNode* root, int level, vector<string>& out, vector<vector<string>>& res){
        string str = "";
        //vector<string> out;
       // vector<vector<string>> res;
        if(level >= words[0].size()){
            res.push_back(out);
            return;
        }
        for(int i=0; i<level; ++i)
            str += out[i][level];
        TrieNode* p = root;
        for(int i=0; i<str.size(); ++i){
            //在Trie树中找符合前缀的所有单词
            if(!p->children[str[i]-'a'])
                return;
            p = p->children[str[i]-'a'];
            
        }
        for(int id : p->index){
            //将符合前缀条件的单词放入out中
            out[level] = words[id];
            dfs(words, root, level+1, out, res);
        }
    }
};

Word Squares:

解题步骤：
Store all words into a trie. Iterate through the words.

• For each word:
• create a new list. Add the word into the list.
• Search the trie for all the words that have the correct prefix. For each of these words:
• Add it to the list.
• Continue searching for the next prefix recursively.
• The recursion reaches its base case when the size of the list is equal to the length of a word. In this case, we've found a word square.