LeetCode-Word Break II

Given a string s and a dictionary of words dict, determine if s can be segmented into a space-separated sequence of one or more dictionary words.

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

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

一看这题目，就感觉里面回溯法，因为这种题，在回溯法中在平常不过了。上代码：

    public boolean wordBreak(String s, Set<String> wordDict) {        if (s == null || wordDict == null) return false;        return dfs(s, wordDict, 0);    }        private boolean dfs(String str, Set<String> wordDict, int s) {    if (s > str.length()) return false;    else if (s == str.length()) return true;    for (int i = s+1; i <= str.length(); i++) {    String sub = str.substring(s, i);    if (wordDict.contains(sub) && dfs(str, wordDict, i)) {    return true;    }    }    return false;    }

标准的回溯方法，但是超时。可以分析一下为什么超时，假设s="aaab"，wordDict={"a", "aa", "aaa"};

看一看递归树：

               a                                                                   aa                    aaa                 aaab

     a           aa  aab                                              a   ab                        b

 a   ab        b                                                    b

b

可以看出重叠子问题，因为在没有找到匹配的时候，会全部遍历这课树，所以可以改用动态规划。

boolean[] can = new boolean[s.length()+1];        can[0] = true;// 空字符串        //f(0, i) = f(0, j) & f(j, i)  k = 0...n-1; i = 0...n        for (int i = 1; i <= s.length(); i++) {            for (int j = 0; j < i; j++) {                 if (can[j] && wordDict.contains(s.substring(j, i))) {                    can[i] = true;                    break;                }            }        }        return can[s.length()];

boolean数组can[i]是指，s.substring(0,i)是可以分割的，所示数组最后一个元素即为所求。

    public boolean wordBreak(String s, Set<String> wordDict) {        boolean[] can = new boolean[s.length()+1];        can[s.length()] = true;        for (int i = s.length()-1; i >= 0; i--) {        for (int j = s.length(); j > i; j--) {        if (wordDict.contains(s.substring(i, j)) && can[j]) {        can[i] = true;        break;        }        }        }        return can[0];    }

另外一个版本，can[i]只值以i为起点的字符串是否在wordDict中

接下来搞word breakII

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

因为要列出所有的可能，所以肯定要用dfs，一个很标准额DFS模板式解答：

public List<String> wordBreak(String s, Set<String> wordDict) {        List<String> list = new ArrayList<String>();    if (s == null || wordDict == null) return list;    dfs(list, s, wordDict, new StringBuilder(), 0);    return list;    }    private void dfs(List<String> list, String s, Set<String> dict, StringBuilder sb, int index) {    if (index == s.length()) {    list.add(new String(sb.toString()));    return;    }    for (int i = index+1; i <= s.length(); i++) {    StringBuilder temp = new StringBuilder(sb);    String sub = s.substring(index, i);    if (dict.contains(sub)) {    if (index != 0)    temp.append(" ");    temp.append(sub);    dfs(list, s, dict, temp, i);    }    }    }

 很显然超时了，怎么办？在DFS中只能剪枝了，我们可以根据word break得出，我们可以先在O(n2)的空间复杂度下跑一下wordbreak，根据其can[]数据进行剪枝

    public List<String> wordBreak(String s, Set<String> wordDict) {        List<String> list = new ArrayList<String>();    if (s == null || wordDict == null) return list;    dfs(list, s, wordDict, new StringBuilder(), check(s, wordDict), 0);    return list;    }    private void dfs(List<String> list, String s, Set<String> dict, StringBuilder sb, boolean[] can, int index) {    if (index == s.length()) {    list.add(new String(sb.toString()));    return;    }    for (int i = index+1; i <= s.length(); i++) {    String sub = s.substring(index, i);    StringBuilder temp = new StringBuilder(sb);    if (dict.contains(sub) && can[i]) {    if (index != 0)    temp.append(" ");    temp.append(sub);    dfs(list, s, dict, temp, can, i);    }    }    }        private boolean[] check(String s, Set<String> wordDict) {        boolean[] can = new boolean[s.length()+1];        can[s.length()] = true;        for (int i = s.length()-1; i >= 0; i--) {        for (int j = s.length(); j > i; j--) {        if (wordDict.contains(s.substring(i, j)) && can[j]) {        can[i] = true;        break;        }        }        }        return can;    }

在DFS的时候，不仅要保证subsring(i, j)在wordDic中，此时还要保证substring(j, length)，此时效率要高很多，不错！