LeetCode - 139/140 - Word Break

Given a non-empty string s and a dictionary wordDict containing a list of non-empty words, determine if s can be segmented into a space-separated sequence of one or more dictionary words. You may assume the dictionary does not contain duplicate words.

For example, given
s = "leetcode",
dict = ["leet", "code"].

Return true because "leetcode" can be segmented as "leet code".

UPDATE (2017/1/4):
The wordDict parameter had been changed to a list of strings (instead of a set of strings). Please reload the code definition to get the latest changes.

判断一个字符串s能否由dict中的字符构成。

这个问题其实具有动态规划的特点。比如计算catsanddog的分割方式，那么倒着想如下：

到了最后一个字符g的时候，
如果能在g之前切一刀，也就是说，如果g在词典中以及catsanddo能够成功切分，那么原字符串就可以成功切分。
或者，如果能在og之前切一刀，也就是说，如果og在词典中以及catsandd能够成功切分，那么原字符串就可以成功切分。
或者，如果能在dog之前切一刀，也就是说，如果dog在词典中以及catsand能够成功切分，那么原字符串就可以成功切分。
或者，如果能在ddog之前切一刀，也就是说，如果ddog在词典中以及catsan能够成功切分，那么原字符串就可以成功切分。
或者，如果能在nddog之前切一刀，也就是说，如果nddog在词典中以及catsa能够成功切分，那么原字符串就可以成功切分。
或者，如果能在anddog之前切一刀，也就是说，如果anddog在词典中以及cats能够成功切分，那么原字符串就可以成功切分。
或者，如果能在sanddog之前切一刀，也就是说，如果sanddog在词典中以及cat能够成功切分，那么原字符串就可以成功切分。
或者，如果能在tsanddog之前切一刀，也就是说，如果tsanddog在词典中以及ca能够成功切分，那么原字符串就可以成功切分。
或者，如果能在atsanddog之前切一刀，也就是说，如果atsanddog在词典中以及c能够成功切分，那么原字符串就可以成功切分。
或者，如果能在catsanddog之前切一刀，也就是说，如果catsanddog在词典中以及""能够成功切分，那么原字符串就可以成功切分。
使用一个数组bool wordB[i] 来记录，在单词长度为i的时候，能否成功切分(i取值范围必然为[ 0, word.length() ] )

时间复杂度O(n^2)，空间复杂度O(n)

class Solution {
public:
    bool wordBreak(string s, vector<string>& wordDict) {
        if (wordDict.empty()) return false;
        
        vector<bool> vis(s.length(), false);
        for (int i = 0; i < s.length(); ++i) {
            if (find(wordDict.begin(), wordDict.end(), s.substr(0, i+1)) != wordDict.end()) {
                vis[i] = true;
                continue;
            }
            for (int j = 0; j < i; ++j) {
                if (vis[j] && find(wordDict.begin(), wordDict.end(), s.substr(j+1, i-j)) != wordDict.end()) {
                    vis[i] = true;
                    break;
                }
            }
        }
        return vis[s.length()-1];
    }
};

140. Word Break II

Given a non-empty string s and a dictionary wordDict containing a list of non-empty words, add spaces in s to construct a sentence where each word is a valid dictionary word. You may assume the dictionary does not contain duplicate words.

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"].

UPDATE (2017/1/4):
The wordDict parameter had been changed to a list of strings (instead of a set of strings). Please reload the code definition to get the latest changes.

判断一个字符串s能由dict中的字符怎样构成。

令s[i..j]表示下标从i到j的子串，它的所有分割情况用words[i]表示

假设s[0..i]的所有分割情况vis[i]已知。则s[0..i+1]的分割情况vis[i+1] = vis[k] + s[k+1..i+1]，其中（有三个条件要满足）(1) 0 <= k < i，(2) vis[k]非空，(3) s[k+1..i+1]在字典中。

对于每个待求解的位置i，从0到i枚举所有的k，然后检验vis[k]是否非空，以及s[k+1..i+1]是否在字典中

最后需要注意的是，最坏情况下枚举的结果是2^n数量级的，此时如果把每个s[0..i]的所有分割情况都保存下来，内存会爆掉。所以只保存s[0..i]分割后的最后一个单词，最后dfs构造所有解。

class Solution {
public:
    vector<string> wordBreak(string s, vector<string>& wordDict) {
        unordered_map<int, vector<string> > vis;
        int len = s.length();
        
        for (int i = 0; i < len; ++i) {
            vector<string> word;
            string cur = s.substr(0, i+1);
            if (find(wordDict.begin(), wordDict.end(), cur) != wordDict.end()) 
                word.push_back(cur);
            
            for (int j = 0; j < i; ++j) {
                vector<string> pre = vis[j];
                cur = s.substr(j+1, i-j);
                if (!pre.empty() && find(wordDict.begin(), wordDict.end(), cur) != wordDict.end())
                    word.push_back(cur);
            }
            
            vis.insert(make_pair(i, word));
        }
        vector<string> ans;
        dfs(ans, vis, s.length()-1, "");
        return ans;
    }
    
    void dfs(vector<string>& ans, unordered_map<int, vector<string> > vis, int pos, string s) {
        if (pos < 0 && s.length()) {
            ans.push_back(s);
            return;
        }
        for (auto w: vis[pos]) {
            string mie = s.length() ? (" " + s) : s;
            dfs(ans, vis, pos-w.length(), w + mie);
        }
    }
};