LC-140 Word Break II

https://leetcode.com/problems/word-break-ii/

给一个字符串s，和一个字符串数组wordDict。现在要用空格把s分隔开，并且保证分割之后的每一部分都可以在wordDict中找到。以字符串数组的形式返回所有的可能分割方式。

例如s = "catsanddog"

wordDict = ["cat", "cats", "and", "sand", "dog"]

则返回结果为：["cat sand dog", "cats and dog"]

 

深度优先搜索：

从字符串头部开始匹配，使用start变量表示当前匹配的位置。对字典中的每个词在start处进行匹配，如果匹配到了，则记录下该词的下标，然后开始下一层搜索。如果字典中所有词都没有匹配到，则从start处开始没有正确答案。

当开始新的一层搜索时发现start已经走完了整个字符串，说明此时整个字符串s都已经被分配成了字典中的词，利用之前记录的更新到这个状态时所有的字典词的下标，更新结果。

这里我做了一个记忆化，利用Results二维数组存储结果，Results[start]表示了从start处开始所有可以匹配的上的字典里词的下标。如果从start处开始无解，则将Results[start]标记为-1，这样可以快速返回无解的信息，防止重复搜索（不对无解情况进行剪枝的话将会超时）

class Solution {
  public:
    vector<vector<int>> Results;
    vector<int> WordsInDict;
    vector<string> ret;

    bool DFS(string &s, vector<string> &wordDict, int start) {
        if (start >= s.length()) {
            // all the sentence was allocated into wordDict
            string NewRet = wordDict[WordsInDict[0]];
            for (int i = 1; i < WordsInDict.size(); i++) {
                NewRet += " " + wordDict[WordsInDict[i]];
            }
            ret.push_back(NewRet);
            return true;
        }

        if (Results[start].size()) {
            // the result of start has already been calculated
            if (Results[start][0] < 0) {
                // start has no valid result
                return false;
            } else {
                int ResultsLen = Results[start].size();
                for (int i = 0; i < ResultsLen; i++) {
                    int DictWordIndex = Results[start][i];
                    WordsInDict.push_back(DictWordIndex);
                    DFS(s, wordDict, start + wordDict[DictWordIndex].length());
                    WordsInDict.pop_back();
                }
                return true;
            }
        } else {
            // the result has not yet been calculated, do the DFS
            int DictLen = wordDict.size();
            bool HasValidResult = false;
            for (int i = 0; i < DictLen; i++) {
                if (string(s, start, wordDict[i].length()) == wordDict[i]) {
                    WordsInDict.push_back(i);
                    bool ok = DFS(s, wordDict, start + wordDict[i].length());
                    WordsInDict.pop_back();
                    if (ok) {
                        Results[start].push_back(i);
                        HasValidResult = true;
                    }
                }
            }
            if (!HasValidResult)
                Results[start].push_back(-1);
            return HasValidResult;
        }
    }

    vector<string> wordBreak(string s, vector<string> &wordDict) {
        int len = s.length();
        for (int i = 0; i < len; i++) {
            vector<int> v;
            Results.push_back(v);
        }
        DFS(s, wordDict, 0);

        return ret;
    }
};