Leetcode: Word Break II

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

难度：98，参考了别人的思路：这道题目要求跟Word Break比较类似，不过返回的结果不仅要知道能不能break，如果可以还要返回所有合法结果。一般来说这种要求会让动态规划的效果减弱很多，因为我们要在过程中记录下所有的合法结果，中间的操作会使得算法的复杂度不再是动态规划的两层循环，因为每次迭代中还需要不是constant的操作，最终复杂度会主要取决于结果的数量，而且还会占用大量的空间，因为不仅要保存最终结果，包括中间的合法结果也要一一保存，否则后面需要历史信息会取不到。所以这道题目我们介绍两种方法，一种是直接brute force用递归解，另一种是跟Word Break思路类似的动态规划。

类似word break中的DP做法，其实就是在word break的基础上稍作修改：

public class Solution {
    public List<String> wordBreak(String s, List<String> wordDict) {
        if (s == null || s.length() == 0) return null;
        List<List<String>> results = new ArrayList<>();

        HashSet<String> dict = new HashSet<>();
        for (String word : wordDict) {
            dict.add(word);
        }
        boolean[] res = new boolean[s.length()+1];
        res[0] = true;
        results.add(new ArrayList<String>());
        results.get(0).add("");
        
        for (int i=1; i<=s.length(); i++) {
            results.add(new ArrayList<String>());
            for (int j=0; j<i; j++) {
                if (res[j]) {
                    String str = s.substring(j, i);
                    if (dict.contains(str)) {
                        res[i] = true;
                        for (String kk : results.get(j)) {
                            if (kk.length() == 0)
                                results.get(i).add(str);
                            else
                                results.get(i).add(kk + " " + str);
                        }
                    }
                }

            }
        }
        return results.get(s.length());
    }
}

还有一点需要指出的是，这个代码放到LeetCode中会MLE，但是面试应该够了，原因是LeetCode中有一个非常tricky的测试case，

Because the existence of test case 'aaaaa...aaaab', ['a', 'aa', 'aaa', ... 'aaa...aa'], the forward DP solution will cause MLE while the backward DP is just fine, apparently the test case 'baaaaaaaa...aaaa', ['a', 'aa', 'aaa', ..., 'aaa...aa'] should also be included.

有时间的话，研究一下vote最高的做法， refer to: https://discuss.leetcode.com/topic/27855/my-concise-java-solution-based-on-memorized-dfs

Solution based on memorized DFS (Top- Down recursion), whereas my approache above is bottom-up recursion and with memorization

Using DFS directly will lead to TLE, so I just used HashMap to save the previous results to prune duplicated branches, as the following:

public List<String> wordBreak(String s, Set<String> wordDict) {
    return DFS(s, wordDict, new HashMap<String, LinkedList<String>>());
}       

// DFS function returns an array including all substrings derived from s.
List<String> DFS(String s, Set<String> wordDict, HashMap<String, LinkedList<String>>map) {
    if (map.containsKey(s)) 
        return map.get(s);
        
    LinkedList<String>res = new LinkedList<String>();     
    if (s.length() == 0) {
        res.add("");
        return res;
    }               
    for (String word : wordDict) {
        if (s.startsWith(word)) {
            List<String>sublist = DFS(s.substring(word.length()), wordDict, map);
            for (String sub : sublist) 
                res.add(word + (sub.isEmpty() ? "" : " ") + sub);               
        }
    }       
    map.put(s, res);
    return res;
}