leetcode 140. 单词拆分 II（回溯法 +前缀树）

给定一个非空字符串 s 和一个包含非空单词列表的字典 wordDict，在字符串中增加空格来构建一个句子，使得句子中所有的单词都在词典中。返回所有这些可能的句子。

说明：

• 分隔时可以重复使用字典中的单词。
• 你可以假设字典中没有重复的单词。

示例 1：

输入:
s = "catsanddog"
wordDict = ["cat", "cats", "and", "sand", "dog"]
输出:
[
  "cats and dog",
  "cat sand dog"
]

示例 2：

输入:
s = "pineapplepenapple"
wordDict = ["apple", "pen", "applepen", "pine", "pineapple"]
输出:
[
  "pine apple pen apple",
  "pineapple pen apple",
  "pine applepen apple"
]
解释: 注意你可以重复使用字典中的单词。

示例 3：

输入:
s = "catsandog"
wordDict = ["cats", "dog", "sand", "and", "cat"]
输出:
[]

解题方法：

leetcode 79. 单词搜索：https://mp.csdn.net/postedit/88660721　

这道题是在单词搜索的基础上，加大了测试数据量，当测试数据wordDict很大时，必然有前缀相同的word，故使用前缀树能减少公共前缀搜索的计算量（此道题如果直接用单词搜索里的函数对wordDict里每一个单词搜索，结果会超时）

leetcode 208. 实现 Trie (前缀树)：https://mp.csdn.net/postedit/88576592

叙述了如果构造前缀树

 

代码：

class TrieNode{
public:
    TrieNode():isWord(false), children(26, nullptr){}
    ~TrieNode(){
        for(auto child : children)
            delete child;
    }
    bool isWord;
    vector<TrieNode*> children;
};
class Solution {
private:
    void addWord(string word){
        if(word.size() == 0) return;
        TrieNode* ptr = _root;
        for(auto w : word){
            if(ptr->children[w - 'a'] == nullptr)
                ptr->children[w - 'a'] = new TrieNode();
            ptr = ptr->children[w - 'a'];
        }
        ptr->isWord = true;
    }
    TrieNode* _root;
public:
    vector<string> findWords(vector<vector<char>>& board, vector<string>& words) {
        vector<string> res;
        if(words.empty() || board.empty() || board[0].empty())
            return res;
        boardFlag = vector<vector<bool>>(board.size(), vector<bool>(board[0].size(), false));
        _root = new TrieNode;
        for(auto word : words)
            addWord(word);
        for(int row = 0; row < board.size(); ++row)
            for(int col = 0; col < board[0].size(); ++col){
                if(_root->children[board[row][col] - 'a'] != NULL){
                    string temp = "";
                    temp += board[row][col]; 
                    dfs(board, res, temp, _root->children[board[row][col] - 'a'], row, col);
                }
            }
        return res;
    }
    
    void dfs(vector<vector<char>>& board, vector<string>& res, string temp, TrieNode* Tire, int row, int col){
        if(Tire->isWord == true){
            res.push_back(temp);
            Tire->isWord = false;
        }
        if(boardFlag[row][col])
            return;
        string addTemp;
        boardFlag[row][col] = true;
        for(auto &a : index){
            int i = row + a[0], j = col + a[1];
            if(i >= 0 && i < board.size() && j >= 0 && j < board[0].size() && boardFlag[i][j] == false && Tire->children[board[i][j] - 'a']){
                addTemp = temp + board[i][j];
                dfs(board, res, addTemp, Tire->children[board[i][j] - 'a'], i, j);
            }
        }
        boardFlag[row][col] = false;
        return ;
    }
    vector<vector<int>> index = {{0, 1}, {0, -1}, {1, 0}, {-1, 0}};
    vector<vector<bool>> boardFlag;
};