Leetcode: 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"]

题目链接：https://oj.leetcode.com/problems/word-break-ii/

方法一：递归实现。这种方法超时！

public class Solution {
    
    private void func(String s, Set<String> dict, int start, String item, ArrayList<String> res) {
        int len = s.length();
        if(start >= len) {
            res.add(item);
            return;
        }
        StringBuilder tmp = new StringBuilder();
        for(int i = start; i < len; i ++) {
            tmp.append(s.charAt(i));
            if(dict.contains(tmp.toString())) {
                String new_item = item.length() > 0 ? item + " " + tmp.toString() : tmp.toString();
                func(s, dict, i+1, new_item, res);
            }
        }
    }
    
    public List<String> wordBreak(String s, Set<String> dict) {
        ArrayList<String> res = new ArrayList<String>();
        if(s == null || s.length() == 0) return res;
       
        func(s, dict, 0, "", res);
        return res;
    }
}

方法二：动态规划。同样超时！

public class Solution {
    
    class Interval {
        int start;
        int end;
        public Interval(int start, int end) {
            this.start = start; this.end = end;
        }
        public Interval(Interval i) {
            start = i.start;
            end = i.end;
     }
    }
    ArrayList<ArrayList<Interval>> deepCopy(ArrayList<ArrayList<Interval>> paths) {
        if (paths==null) return null;
        ArrayList<ArrayList<Interval>> res = new ArrayList<ArrayList<Interval>>(paths.size());
        for (int i=0; i<paths.size(); i++) {
         ArrayList<Interval> path = paths.get(i);
         ArrayList<Interval> copy = new ArrayList<Interval>(path.size());
            for (int j=0; j<path.size(); j++) {
             copy.add(new Interval(path.get(j)));
         }
         res.add(copy);
        }
        return res;
    }
    public ArrayList<String> wordBreak(String s, Set<String> dict) {
        ArrayList<String> res = new ArrayList<String>();
        if (s==null || s.length()==0) return res;
        Map<Integer, ArrayList<ArrayList<Interval>>> dp = new HashMap<Integer, ArrayList<ArrayList<Interval>>>();
        dp.put(0, new ArrayList<ArrayList<Interval>>());
        dp.get(0).add(new ArrayList<Interval>());
        for (int i=1; i<=s.length(); i++) {
            for (int j=0; j<i; j++) {
                String cur = s.substring(j, i);
                ArrayList<ArrayList<Interval>> paths = null;
                if (dp.containsKey(j) && dict.contains(cur)) {
                    paths = deepCopy(dp.get(j));
                    Interval interval = new Interval(j, i);
                    for (ArrayList<Interval> path:paths) {
                        path.add(interval);
                    }
                }
                if (paths != null) {
                    if (!dp.containsKey(i)) {
                        dp.put(i, paths);
                    } 
                    else {
                  dp.get(i).addAll(paths);
                 }
                }
            }
        }
        if (!dp.containsKey(s.length())) {
            return res;
        }
        ArrayList<ArrayList<Interval>> paths = dp.get(s.length());
        for (int j=0; j<paths.size(); j++) {
            ArrayList<Interval> path = paths.get(j);
            StringBuilder str = new StringBuilder();
            for (int i=0; i<path.size(); i++) {
                if (i!=0) {str.append(" ");}
                int start = path.get(i).start;
                int end = path.get(i).end;
                str.append(s.substring(start, end));
            }
            res.add(str.toString());
        }
        return res;
    }
}