140 Word Break II [Leetcode]

题目内容：

Given a string s and a dictionary of words dict, add spaces in s to construct a sentence where each word is a valid dictionary word.

Return all such possible sentences.

For example, given
s = “catsanddog”,
dict = [“cat”, “cats”, “and”, “sand”, “dog”].

A solution is [“cats and dog”, “cat sand dog”].

解题思路：
首先尝试简单的回溯，代码如下：

class Solution {public:    vector<string> wordBreak(string s, unordered_set<string>& wordDict) {        vector<string> result;        getSentences(wordDict, result, s, 0, "");        return result;    }    void getSentences(unordered_set<string>& wordDict, vector<string> &sentences, string &s, int index, string temp) {        int size(s.size());        if(index == size)            sentences.push_back(temp.substr(1));        for(int i = index; i < size; ++i) {            string str = s.substr(index, i-index+1);            if(wordDict.find(str) != wordDict.end()) {                getSentences(wordDict, sentences, s, i+1, temp + " " + str);            }        }    }};

超时，特例如：
“aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaab”
[“a”,”aa”,”aaa”,”aaaa”,”aaaaa”,”aaaaaa”,”aaaaaaa”,”aaaaaaaa”,”aaaaaaaaa”,”aaaaaaaaaa”]
还是需要把中间结果保存起来，使用动态规划来做。

使用二维数组vector<vector<string>>来存从i到j的在字典中的查找得到的中间结果，首先判断[0,i]的子串是否在字典中，若有，添加分割方法；其次，再从后向前判断[j,i]是否在字典中，若在字典中且[0,j]有解，那么添加方法。
代码实现如下：

class Solution {public:    vector<string> wordBreak(string s, unordered_set<string>& wordDict) {        int size(s.size());        vector<vector<string>> sentences;        sentences.resize(size);        for(int i = 0; i < size; ++i) {            string sstr = s.substr(0, i+1);            if(wordDict.find(sstr) != wordDict.end()) {                sentences[i].push_back(sstr);            }            for(int j = i; j > 0; --j) {                string tstr = s.substr(j, i-j+1);                if(wordDict.find(tstr) != wordDict.end() && sentences[j-1].size() != 0) {                    for(int k = 0; k < sentences[j-1].size(); ++k) {                        string temp = sentences[j-1][k] + " " + tstr;                        sentences[i].push_back(temp);                    }                }            }        }        return sentences[size-1];    }};

和前面的方法一样，遇到一样的情况时，会出现超时问题。原因猜想是字符串的拼接是一个比较耗时的操作，而上述代码求解中间结果需要大量的字符串拼接的操作。

如何把字符串拼接的中间结果操作忽略，直接计算出拼接的结果是下一步提速要解决的问题。值得注意的一点是，我们其实无需把字符串拼接的那么多中间结果都存起来。因为字符串是一样的，不一样的只是分割的位置，我们可以只把分割的位置记录下来。

另外，还有一个要考虑的是内存问题。如果把中间结果都叠加得保存起来，可能会需要大量的内存。因此我们修改了动态规划存储的中间结果的内容，即只存储由哪些下标可以跳转到当前的下标。这样，在最后通过一次回溯或者栈操作实现的DFS，就可以把最后的结果都保存下来。

代码如下，运行时间20ms，这里的回溯使用了递归实现，如果用栈应该能更快些。

class Solution {public:    vector<string> wordBreak(string s, unordered_set<string>& wordDict) {        int size(s.size());        vector<vector<int>> sentences(size);        for(int i = 0; i < size; ++i) {            if(wordDict.find(s.substr(0, i+1)) != wordDict.end()) {                sentences[i].push_back(0);            }            for(int j = i; j > 0; --j) {                if(wordDict.find(s.substr(j, i-j+1)) != wordDict.end() && sentences[j-1].size() != 0) {                    sentences[i].push_back(j);                }            }        }        vector<string> result;        getSentences(sentences, s, result, size-1, "");        return result;    }    void getSentences(vector<vector<int>> &breaks, string &s, vector<string> &output, int index, string mid_result) {        if(index == -1) {            if(mid_result != "")                mid_result.pop_back();            output.push_back(mid_result);            return;        }        int size(breaks[index].size());        for(int i = 0; i < size; ++i) {            string temp = s.substr(breaks[index][i], index-breaks[index][i]+1) + " " + mid_result;            getSentences(breaks, s, output, breaks[index][i]-1, temp);        }    }};