Word Break II 解答

Question

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

Solution

这题的基本思路是用recursion，每次都只研究第一刀切在哪儿，然后对剩下的substring做递归。但是我们发现其实可以借助DP的思想，存下来部分中间结果值。这种思想也叫 Memorized Recursion。

Memorized recursion并不是一个很好的方法，但是当遇到time limit exceed时可以想到它来拿空间换时间

 class Solution:
     # @param s, a string
     # @param dict, a set of string
     # @return a list of strings
     def wordBreak(self, s, dict):
         self.dict = dict
         # cache stores tmp results: key: substring value: list of results
         self.cache = {}
         return self.break_helper(s)

     def break_helper(self, s):
         combs = []
         if s in self.cache:
             return self.cache[s]
         if len(s) == 0:
             return []

         for i in range(len(s)):
             if s[:i+1] in self.dict:
                 if i == len(s) - 1:
                     combs.append(s[:i+1])
                 else:
                     sub_combs = self.break_helper(s[i+1:])
                     for sub_comb in sub_combs:
                         combs.append(s[:i+1] + ' ' + sub_comb)

         self.cache[s] = combs
         return combs

第二种思路：先用DP，再用DFS

dp[i] 为list<String>表示以i结尾的在word dict中的词，并且满足dp[i - wordLen]不是null。

DFS从dp[len]开始，遍历可能的词。

 public class Solution {
     public List<String> wordBreak(String s, Set<String> wordDict) {
         List<String> result = new ArrayList<>();
         if (wordDict == null || s == null) {
             return result;
         }
         int len = s.length();
         ArrayList<String>[] dp = new ArrayList[len + 1];
         dp[0] = new ArrayList<String>();
         for (int i = 0; i < len; i++) {
             if (dp[i] != null) {
                 for (int j = i + 1; j <= len; j++) {
                     String sub = s.substring(i, j);
                     if (wordDict.contains(sub)) {
                         if (dp[j] == null) {
                             dp[j] = new ArrayList<String>();
                         }
                         dp[j].add(sub);
                     }
                 }
             }
         }
         if (dp[len] == null) {
             return result;
         }
         // dfs
         dfs(dp, result, "", len);
         return result;
     }

     private void dfs(ArrayList<String>[] dp, List<String> result, String tail, int curPos) {
         if (curPos == 0) {
             result.add(tail.trim());
             return;
         }
         for (String str : dp[curPos]) {
             String curStr = str + " " + tail;
             dfs(dp, result, curStr, curPos - str.length());
         }
     }
 }