leetcode212 单词搜索

单词搜索的高级形式，在同一个矩阵中搜索多个单词。因为刚刚完成了tire也就是前缀树的撰写，整体写起来并不困难，使用深度优先搜索的递归就可以。然而问题出在效率上，尤其是所需要进行搜索的单词数量比较多的时候。进行了一些方面的修改。第一点是在完成一个单词的搜索之后就将该单词对应node的isend标志修改为false，防止出现同样的单词被搜索两次的情况。第二个问题是在递归的过程中，dfs函数可以加上一个node参数，代表上一个字符所对应的节点，所以在递归过程中不需要苦大仇深的去调用判断是否为前缀的函数，只需要判断当前搜索到的字符是否是这个节点的某一子节点，若是子节点了，那判断是不是某一单词的结尾，这样就省去了调用函数的消耗。第三点，可以在某一字符串结尾处的节点加上一个string类型的变量，这样若是判断该节点搜索到了某一单词，就直接将该节点的这一变量送上去，而不需要在dfs中增加一个string类型的变量以指示当前的字符串。修改完这三个问题，效率就有较大的提升。贴代码

//前缀树
class Trie {
public:
    string word;
    vector<Trie*> children;
    bool isEnd;

    /** Initialize your data structure here. */
    Trie():children(26),isEnd(false){}
    
    /** Inserts a word into the trie. */
    void insert(string word) 
    {
        Trie* node = this;
        for(auto temp:word)
        {
            temp -= 'a';
            if(node->children[temp] == nullptr)
            {
                node->children[temp] = new Trie();
            }
            node = node->children[temp];
        }
        node->isEnd = true;
        node->word = word;
    }
    
    /** Returns if the word is in the trie. */
    bool search(string word) 
    {
        Trie* node = this;
        for(auto temp:word)
        {
            temp -= 'a';
            if(node->children[temp] != nullptr)
            node = node->children[temp];
            else
            return false;
        }
        if(node->isEnd)
        return true;
        else
        return false;        
    }
    
    /** Returns if there is any word in the trie that starts with the given prefix. */
    bool startsWith(string prefix) 
    {
        Trie* node = this;
        for(auto temp:prefix)
        {
            temp -= 'a';
            if(node->children[temp] != nullptr)
            node = node->children[temp];
            else
            return false;
        }
        return true;
    }

    bool deleteWord(string word)
    {
        if(this->search(word))
        {
            Trie* node = this;
            for(auto temp:word)
            {
                temp -= 'a';
                if(node->children[temp] != nullptr)
                node = node->children[temp];
                else
                return false;
            }
            node->isEnd = false;
            return true;
        }
        return false;
    }
};
class Solution {
public:
    Trie* root;
    int m;
    int n; 
    vector<string> res;   
    vector<string> findWords(vector<vector<char>>& board, vector<string>& words) 
    {
        root = new Trie();
        for(auto word:words)
        root->insert(word);
        m = board.size();
        n = board[0].size();
        set<string> ans;
        for(int i = 0 ; i < m ; i++)
        {
            for(int j = 0 ; j < n ; j++)
            {
                string temp;
                temp.push_back(board[i][j]);
                if(root->startsWith(temp))
                dfs(board,i,j,root);             
            }
        }
        return res;
    }
    void dfs(vector<vector<char>>& board,int i,int j,Trie* node)
    {
        char t = board[i][j];
        int p = t-'a';
        board[i][j] = '0';
        if(node->children[p]!=nullptr && node->children[p]->isEnd)
        {
            res.push_back(node->children[p]->word);
            node->children[p]->isEnd = false;
        }
        if(node->children[p]!=nullptr)
        {
            node = node->children[p];
            if(i+1<m && board[i+1][j] != '0')
            dfs(board,i+1,j,node);
            if(i-1>=0 && board[i-1][j] != '0')
            dfs(board,i-1,j,node);
            if(j+1<n && board[i][j+1] != '0')
            dfs(board,i,j+1,node);
            if(j-1>=0 && board[i][j-1] != '0')
            dfs(board,i,j-1,node);
        }
        board[i][j] = t;        
    }

};