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());
        }
    }