leetcode 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完全分割，并且返回所有分割的组合。
这道题还是比较明显的可以用dfs做，从s左边开始，遇到能匹配的就递归一直往右边搜索，否则返回，当到达s末尾，就是一个可达路径，是其中的一个解。
这道题有一个testcase很容易超时，比如当s=”aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaabaabaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa”
dict={“aaaaa”,”ba”,”aaa”}时，中间的baab是不能完全被分割的，用递归要搜索很久才能判断出来。
因此还是先调用leetcode 139. Word Break先判断字段串能不能被完整分割，再做递归才不会超时。

List<String> resultList = new ArrayList<String>();

     public List<String> wordBreak(String s, List<String> wordDict) {
         if(!wordBreak2(s,wordDict)){
             return new ArrayList<String>();
         }
         resultList = new ArrayList<String>();
         wordBreak(s,wordDict,"");
         return resultList;   
     }
     public void wordBreak(String leftStr, List<String> wordDict,String resultStr) {
         if(leftStr == null || "".equals(leftStr)){
             resultList.add(resultStr.trim());
             return;
         }
         for(String str : wordDict){
             if(leftStr.startsWith(str)){
                 resultStr += str + " ";
                 wordBreak(leftStr.substring(str.length()),wordDict,resultStr);
                 resultStr = resultStr.trim();
                 resultStr = resultStr.substring(0,resultStr.length()-str.length());
             }

         }

     }
    public boolean wordBreak2(String s, List<String> wordDict) {
        if(s == null || s.equals("")){
            return true;
        }
        boolean[] dp = new boolean[s.length()+1];
        dp[0] = true;
        for(int i =0;i<s.length();i++){
            for(String str : wordDict){
                if(dp[i] && s.substring(i).startsWith(str)){
                    dp[i+str.length()] = true;
                    if(i+str.length()==s.length()){
                        return true;
                    }
                }

            }

        }
       return false;
    }

这种解法用了27ms，在遍历dict list时做匹配耗时还是不少，另一种方式是在s上从左往右移动，遇到包含在dict的串时做递归，这样就可以直接用set的contains做匹配，因为HashSet是基于HashMap，contains是常数时间，比遍历List更快

List<String> resultList = new ArrayList<String>();

     public List<String> wordBreak(String s, List<String> wordDict) {
          if(!wordBreak2(s,wordDict)){
             return new ArrayList<String>();
         }
        Set<String>set = new HashSet<String>();
         Set<String>wordDictSet = new HashSet<String>(wordDict);

         resultList = new ArrayList<String>();
         wordBreak(s,wordDictSet,"");
         return resultList;   
     }
     public void wordBreak(String leftStr, Set<String> wordDict,String resultStr) {
         if(leftStr == null || "".equals(leftStr)){
             resultList.add(resultStr.substring(0, resultStr.length()-1));
             return;
         }
         StringBuilder leftStrBuilder = new StringBuilder();
         for(int i=0;i<leftStr.length();i++){
             leftStrBuilder.append(leftStr.charAt(i));
             if(wordDict.contains(leftStrBuilder.toString())){
                 resultStr += leftStrBuilder.toString() + " ";
                 wordBreak(leftStr.substring(leftStrBuilder.length()),wordDict,resultStr);
                 resultStr = resultStr.substring(0,resultStr.length()-leftStrBuilder.length()-1);
             }
         }

     }

    public boolean wordBreak2(String s, List<String> wordDict) {
        if(s == null || s.equals("")){
            return true;
        }
        boolean[] dp = new boolean[s.length()+1];
        dp[0] = true;
        for(int i =0;i<s.length();i++){
            for(String str : wordDict){
                if(dp[i] && s.substring(i).startsWith(str)){
                    dp[i+str.length()] = true;
                    if(i+str.length()==s.length()){
                        return true;
                    }
                }

            }

        }
       return false;
    }

此种方法耗时20ms，相对上一种有了些许提升，但如果dict规模更大，性能上优势也会比上一种解法更明显