LeetCode: Word Break II 解题报告

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

解答1 (dfs)：
让我们来继续切切切吧！

本题与上一题Word Break思路类似，但是一个是DP,一个是DFS。
让我们来回顾一下DP与DFS的区别：
DP是Bottom-up 而DFS是TOP-DOWN.

在本题的DFS中，我们这样定义：
用刀在字符串中切一刀。左边是i个字符，右边是len-i个字符。
i: 1- len
如果： 左边是字典里的词，右边是可以wordbreak的，那么把左边的字符串加到右边算出来的List中，生成新的list返回。
1. Base case:
当输入字符串为空的时候，应该给出一个空解。这个很重要，否则这个递归是不能运行的。
2. 递归的时候，i应该从1开始递归，因为我们要把这个问题分解为2个部分，如果你左边给0，那就是死循环。

记忆：
为了加快DFS的速度，我们应该添加记忆，也就是说，算过的字符串不要再重复计算。举例子：
apple n feng
app len feng
如果存在以上2种划分，那么feng这个字符串会被反复计算，在这里至少计算了2次。我们使用一个Hashmap把对应字符串的解记下来，这样就能避免重复的计算。 否则这一道题目会超时。

// 我们用DFS来解决这个问题吧 
    public static List<String> wordBreak1(String s, Set<String> dict) {
        HashMap<String, List<String>> map = new HashMap<String, List<String>>();
        if (s == null || s.length() == 0 || dict == null) {
            return null;
        }

        return dfs(s, dict, map);
    }

    // 解法1：我们用DFS来解决这个问题吧 
    public static List<String> dfs(String s, Set<String> dict, HashMap<String, List<String>> map) {
        if (map.containsKey(s)) {
            return map.get(s);
        }

        List<String> list = new ArrayList<String>();
        int len = s.length();

        if (len == 0) {
            list.add("");
        } else {
            // i 表示左边字符串的长度
            for (int i = 1; i <= len; i++) {
                String sub = s.substring(0, i);

                // 左边的子串可以为空，或是在字典内
                if (!dict.contains(sub)) {
                    continue;
                }

                // 字符串划分为2边，计算右边的word break.
                List<String> listRight = dfs(s.substring(i, len), dict, map);

                // 右边不能break的时候，我们跳过.
                if (listRight.size() == 0) {
                    continue;
                }

                // 把左字符串加到右字符串中，形成新的解.
                for (String r: listRight) {
                    StringBuilder sb = new StringBuilder();
                    sb.append(sub);
                    if (i != 0 && i != len) {
                        // 如果左边为空，或是右边为空，不需要贴空格
                        sb.append(" ");
                    }
                    sb.append(r);
                    list.add(sb.toString());
                }
            }
        }

        map.put(s, list);
        return list;
    }

解答2： dfs2：
参考了http://blog.csdn.net/fightforyourdream/article/details/38530983的 解法，我们仍然使用主页君用了好多次的递归模板。但是在LeetCode中超时，在进入DFS时加了一个『判断是不是wordBreak』的判断，终于过了。这是一种DFS+剪枝的解法

/*
    // 解法2：我们用普通的递归模板来试一下。
    */
    
    // 我们用DFS来解决这个问题吧 
    public static List<String> wordBreak(String s, Set<String> dict) {
        if (s == null || s.length() == 0 || dict == null) {
            return null;
        }
        
        List<String> ret = new ArrayList<String>();
        
        // 记录切割过程中生成的字母
        List<String> path = new ArrayList<String>();
            
        dfs2(s, dict, path, ret, 0);
        
        return ret;
    }

    // 我们用DFS模板来解决这个问题吧 
    public static void dfs2(String s, Set<String> dict, 
            List<String> path, List<String> ret, int index) {
        int len = s.length();
        if (index == len) {
            // 结束了。index到了末尾
            StringBuilder sb = new StringBuilder();
            for (String str: path) {
                sb.append(str);
                sb.append(" ");
            }
            // remove the last " "
            sb.deleteCharAt(sb.length() - 1);
            ret.add(sb.toString());
            return;
        }
        
        // 如果不加上这一行会超时。就是说不能break的时候，可以直接返回
        // 但这也许只是一个treak, 其实这种方法还是不大好。
        if (!iswordBreak(s.substring(index), dict)) {
            return;
        }

        for (int i =  index; i < len; i++) {
            // 注意这些索引的取值。左字符串的长度从0到len
            String left = s.substring(index, i + 1);
            if (!dict.contains(left)) {
                // 如果左字符串不在字典中，不需要继续递归
                continue;
            }

            path.add(left);
            dfs2(s, dict, path, ret, i + 1);
            path.remove(path.size() - 1);
        }
    }
    
    public static boolean iswordBreak(String s, Set<String> dict) {
        if (s == null) {
            return false;
        }
        
        int len = s.length();
        if (len == 0) {
            return true;
        }
        
        boolean[] D = new boolean[len + 1];

        // initiate the DP. 注意，这里设置为true是不得已，因为当我们划分字串为左边为0，右边为n的时候，
        // 而右边的n是一个字典string,那么左边必然要设置为true，才能使结果为true。所以空字符串我们需要
        // 认为true
        D[0] = true;
        
        // D[i] 表示i长度的字符串能否被word break.
        for (int i = 1; i <= len; i++) {
            // 把子串划分为2部分，分别讨论, j 表示左边的字符串的长度
            // 成立的条件是：左边可以break, 而右边是一个字典单词
            D[i] = false;
            for (int j = 0; j < i; j++) {
                if (D[j] && dict.contains(s.substring(j, i))) {
                    // 只要找到任意一个符合条件，我们就可以BREAK; 表示我们检查的
                    // 这一个子串符合题意
                    D[i] = true;
                    break;
                }
            }
        }

        return D[len];
    }

解答3： dfs3：

感谢http://fisherlei.blogspot.com/2013/11/leetcode-wordbreak-ii-solution.html的解释，我们可以加一个boolean的数组，b[i]表示从i到len的的字串可不可以进行word break. 如果我们在当前根本没有找到任何的word， 也就表明这一串是不能word break的，记一个false在数组里。这样下次进入dfs这里的时候，直接就返回一个false.通过这个剪枝我们也可以减少复杂度。

/*
    // 解法3：重新剪枝。
    */
    // 我们用DFS来解决这个问题吧 
    public static List<String> wordBreak3(String s, Set<String> dict) {
        if (s == null || s.length() == 0 || dict == null) {
            return null;
        }
        
        List<String> ret = new ArrayList<String>();
        
        // 记录切割过程中生成的字母
        List<String> path = new ArrayList<String>();
        
        int len = s.length();
        
        // 注意：一定要分配 Len+1 否则会爆哦.
        boolean canBreak[] = new boolean[len + 1];
        for (int i = 0; i < len + 1; i++) {
            canBreak[i] = true;
        }
            
        dfs3(s, dict, path, ret, 0, canBreak);
        
        return ret;
    }

    // 我们用DFS模板来解决这个问题吧 
    public static void dfs3(String s, Set<String> dict, 
            List<String> path, List<String> ret, int index,
            boolean canBreak[]) {
        int len = s.length();
        if (index == len) {
            // 结束了。index到了末尾
            StringBuilder sb = new StringBuilder();
            for (String str: path) {
                sb.append(str);
                sb.append(" ");
            }
            // remove the last " "
            sb.deleteCharAt(sb.length() - 1);
            ret.add(sb.toString());
            return;
        }
        
        // if can't break, we exit directly.
        if (!canBreak[index]) {
            return;
        }

        for (int i =  index; i < len; i++) {
            // 注意这些索引的取值。左字符串的长度从0到len
            String left = s.substring(index, i + 1);
            if (!dict.contains(left) || !canBreak[i + 1]) {
                // 如果左字符串不在字典中，不需要继续递归
                continue;
            }
            
            // if can't find any solution, return false, other set it 
            // to be true;
            path.add(left);
            
            int beforeChange = ret.size();
            dfs3(s, dict, path, ret, i + 1, canBreak);
            // 注意这些剪枝的代码. 关键在于此以减少复杂度
            if (ret.size() == beforeChange) {
                canBreak[i + 1] = false;    
            }
            path.remove(path.size() - 1);
        }
    }

解答4： DP解法：

感谢大神的解法： https://gist.github.com/anonymous/92e5e613aa7b5ce3d4c5 以后再慢慢研究

主页君自己也写了一个先用动规算出哪些区间是可以解的，然后在DFS的时候，先判断某区间能否word break，如果不可以，直接退出。

    /*
    // 解法4：先用DP来求解某些字段是否能word break，然后再做 
    */
    // 我们用DFS来解决这个问题吧 
    public static List<String> wordBreak4(String s, Set<String> dict) {
        if (s == null || s.length() == 0 || dict == null) {
            return null;
        }
        
        List<String> ret = new ArrayList<String>();
        
        List<String> path = new ArrayList<String>();
        
        int len = s.length();
        
        // i: 表示从i索引开始的字串可以word break.
        boolean[] D = new boolean[len + 1];
        D[len] = true;
        for (int i = len - 1; i >= 0; i--) {
            for (int j = i; j <= len - 1; j++) {
                // 左边从i 到 j
                D[i] = false;
                if (D[j + 1] && dict.contains(s.substring(i, j + 1))) {
                    D[i] = true;
                    break;
                }
            }
        }

        dfs4(s, dict, path, ret, 0, D);
        
        return ret;
    }

    public static void dfs4(String s, Set<String> dict, 
            List<String> path, List<String> ret, int index,
            boolean canBreak[]) {
        int len = s.length();
        if (index == len) {
            // 结束了。index到了末尾
            StringBuilder sb = new StringBuilder();
            for (String str: path) {
                sb.append(str);
                sb.append(" ");
            }
            // remove the last " "
            sb.deleteCharAt(sb.length() - 1);
            ret.add(sb.toString());
            return;
        }
        
        // if can't break, we exit directly.
        if (!canBreak[index]) {
            return;
        }

        for (int i =  index; i < len; i++) {
            // 注意这些索引的取值。左字符串的长度从0到len
            String left = s.substring(index, i + 1);
            if (!dict.contains(left)) {
                // 如果左字符串不在字典中，不需要继续递归
                continue;
            }
            
            // if can't find any solution, return false, other set it 
            // to be true;
            path.add(left);
            dfs4(s, dict, path, ret, i + 1, canBreak);
            path.remove(path.size() - 1);
        }

    }

比较与测试：

这里贴一下各种解法的时间：

Test
Computing time with DFS1: 7830.0 millisec.
Computing time with DFS2: 6400.0 millisec.
Computing time with DFS3: 4728.0 millisec.
Computing time with DFS4: 4566.0 millisec.

可见，四个方法里最好的是第四个，建议面试时可以采用第四个。如有错误，敬请指正。

GitHub代码链接