Word Break I II

Word Break

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

解法1，递归，超时

有两种递归方式，一种是按s的子串递归，一种是按集合dict递归

第一种：

 public boolean wordBreak(String s, Set<String> dict) {
         if(dict.contains(s)){
             return true;
         }
         boolean flag = false;
         for(int i=1;i<s.length();i++){
             if(dict.contains(s.substring(0,i))){
                 flag = wordBreak(s.substring(i),dict);
             }
         }
         return flag;
     }

第二种：

 public boolean wordBreak(String s, Set<String> dict) {
         if(dict.contains(s)||s.equals("")){
             return true;
         }
         boolean flag = false;
         for(String now:dict){
             for(int i = 0;i<s.length()-now.length();i++){
                 if(s.substring(i, i+now.length()).equals(now)){
                     flag = wordBreak(s.substring(0,i), dict)&&wordBreak(s.substring(i+now.length()), dict);
                     if(flag){
                         return true;
                     }
                 }
             }
         }
         return flag;
     }

解法2：动态规划

设flag[]为boolean数组，flag[i]表示s.substring(0,i)是否满足wordbreak，因此有状态转移方程为：

flag[n] = ∑flag[i]&&s.substring(i,n)   (i 取值为从1到n-1)，有代码如下：

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

递归的复杂度为O(2^n)，动态规划的复杂度为O(n^2)

个人感觉，动态规划版本就是递归中第一种解法的非递归版，递归是自顶向下计算，动态规划是自底向上计算。

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

做法与上面相似，boolean数组变成list<Integer>的数组，记录当前位可以从前面哪些位得出，先自底向上生成数组，然后自顶向下构造字符串，直接贴代码：

 private List<String> result = new ArrayList<String>();
     public List<String> wordBreak(String s, Set<String> dict) {
         List<List<Integer>> flag = new ArrayList<List<Integer>>();
         List<Integer> temp = new ArrayList<Integer>();
         temp.add(0);
         flag.add(temp);
         for (int i = 1; i <= s.length(); i++) {
             temp = new ArrayList<Integer>();
             for (int j = 0; j < i; j++) {
                 if (dict.contains(s.substring(j, i)) && flag.get(j).size() > 0) {
                     temp.add(j);
                 }
             }
             flag.add(temp);
         }
         genList(flag, s, "", flag.get(flag.size() - 1), flag.size() - 1);
         return result;
     }

     private void genList(List<List<Integer>> flag, String source, String now,
             List<Integer> list, int pos) {
         // TODO Auto-generated method stub
         if (pos == 0) {
             result.add(now);
             return;
         }
         for (Integer i : list) {
             String temp = "";
             if (now.equals("")) {
                 temp = source.substring(i, pos);

             } else {
                 temp = source.substring(i, pos) + " " + now;
             }
             genList(flag, source, temp, flag.get(i), i.intValue());
         }
     }