单词拆分II

Lintcode 582

已知：

给一字串s和单词的字典dict,在字串中增加空格来构建一个句子，并且所有单词都来自字典。
返回所有有可能的句子。

示例：

给一字串lintcode,字典为["de", "ding", "co", "code", "lint"]
则结果为["lint code", "lint co de"]。

思路：
用动态规划的思路，这道题目按照递归是很容易解决的。

首先，我们找到字典dict中所有可以作为字串s的开头的string；
然后，结果返回为  string + 函数(余下的s部分，字典dict)
因为返回是一个list集合，所以list中所有数据都要和string连接一次（我在相应代码会特别注释）

当然，实际考虑到一些特殊情况，运行效率可能还能够有所提升，但是基础的代码部分是相当简单的。

代码如下：

public class Solution {
    public List<String> wordBreak(String s, Set<String> wordDict) {
        List<String> ret = new ArrayList<String>();

        //如果set中包含"",也就是长度为0的字符串，就会死循环
        while (wordDict.contains("")) {
            wordDict.remove("");
        }

        /*
        //特殊情况1：s中一个元素是dict中不存在的，返回必为空
        //"aaaaaabaaaaaaaaaaaaa"
        //["a","aa","aaa","aaaa","aaaaa","aaaaaa"]
        Set<Character> set1 = calculate(s);
        Set<Character> set2 = calculate(ToString(wordDict));
        if (!set2.containsAll(set1)) {
            return ret;
        }

        //这里的代码比较无奈，因为注释以外的代码时间复杂度不高，运行很快，但是通不过，也就是下面这种特殊情况时间复杂度过高   
        //特殊情况2：
        //"aaaaaaaabaaaaaaaaaa"
        //["a","b","aa","aaa","aaaa","aaaaa","aaaaaa"]
        int count = 0;
        String unique = null;
        for (String temp : wordDict) {
            if ((s.split(temp).length == 2) && (!s.endsWith(temp))&& (!s.startsWith(temp))){
                count++;
                unique = temp;
            }
        }
        if (count == 1 && unique(unique, wordDict)) {
            wordDict.remove(unique);
            List<String> list1 = wordBreak(s.substring(0, s.indexOf(unique)),
                    wordDict);
            List<String> list2 = wordBreak(
                    s.substring(s.indexOf(unique) + unique.length()), wordDict);
            for (String temp1 : list1) {
                for (String temp2 : list2) {
                    ret.add(temp1 + " " + unique + " " + temp2);
                }
            }
            return ret;
        }
       */

        for (String temp : wordDict) {
            if (temp.equals(s)) {
                ret.add(temp);
            }
            if (s.startsWith(temp)) {
                List<String> smallWordBreak = wordBreak(
                        s.substring(temp.length()), wordDict);
                for (String small : smallWordBreak) {
                    ret.add(temp + " " + small);
                }
            }
        }
        return ret;
    }

    private static boolean unique(String unique, Set<String> wordDict) {
        int count = 0;
        for (String s : wordDict) {
            if (s.contains(unique)) {
                count++;
            }
        }
        return count == 1;
    }

    private static String ToString(Set<String> wordDict) {
        StringBuilder ret = new StringBuilder();
        for (String s : wordDict) {
            ret.append(s);
        }
        return ret.toString();
    }

    private static Set<Character> calculate(String s) {
        Set<Character> ret = new TreeSet<Character>();
        char[] cs = s.toCharArray();
        for (char c : cs) {
            ret.add(c);
        }
        return ret;
    }
}

以上注释外的代码是初始代码，其实即使是最后一个案例，通过时间也是很短的，总共128*512中情况，但是检测系统不给通过，无奈之下有了注释内的代码，将s分成左右两段分别获得list（但是代码通用性还是不高，只是用来应付一下，真正的高通用性应该是dict中的某数据是dict中唯一含有特定字符的数据，且这个数据出现在了s中，但是这其实已经是特殊情况了，放在正常情况下反而增加了很多额外工作量，因此就没深入去写了）

以上，谢谢您的阅读，希望对您有所帮助ヽ(￣▽￣)ﾉ