LeetCode - Word Break

题注

大情人节的做编程题还真是有点说不过去呢… 不过也算是对我自己的一种惩罚了，谁让以前错过了真爱，现在对除了她以外的其他女孩子一点兴趣都提不起来呢… 没事没事，安慰下自己吧。话说不太想按照AC Rate的顺序做题了，每次点来点去的太麻烦，找感兴趣的做吧！

这道题刚开始看的时候一点思路都没有，然后有了点思路后发现是错的，最后还是通过Discuss才知道正确的解决方法是什么，有种自己弱爆了的感觉，嗯…

题目

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

分析

这道题开始的时候我用了一个特别esay的代码进行解决：不就是拆分嘛。先看前面的substring是不是dict里面的，如果是，就检查后面substring是不是dict里面的，如此循环。唉，描述起来不太轻松，直接上代码吧：

public class Solution {
    public boolean wordBreak(String s, Set<String> dict) {
        if (s == null || s.isEmpty()){
            return false;
        }
        if (dict.contains(s)){
            return true;
        }

        for(int i = 1 ; i < s.length(); i ++){
            if(dict.contains(s.substring(0,i))){
                return wordBreak(s.substring(i), dict);

            }
        }
        return false;
    }
}

结果提交这个代码后，一共21个test，前20个都过了，最后1个就是通过不了。看了看discuss，比人也有类似的问题。通过不了的具体例子我就不列出来了，那个test的原始数据太麻烦，我在此举简单的一个例子进行说明。

如果s = "leetcodes"，dict = ["leet", "co", "es", "leetcode", "s"]。问题就来了，按照代码的算法，我们先检查到前面的"leet"是一个词，但是"codes"在dict中没法再拆了，因此结果返回false。然而，实际上我们还可以用"leetcode" + "s"这种拆法。因此，这个算法是错误的。

我本来想到了一个简单的改正方法，具体来说就是，如果

wordBreak(s.substring(i), dict);

这句话返回的是false，那么代码并不停止，而是继续进行循环检查。这似乎是一个很简单的修改方法，代码如下：

public class Solution {
    public boolean wordBreak(String s, Set<String> dict) {
        if (s == null || s.isEmpty()){
            return false;
        }
        if (dict.contains(s)){
            return true;
        }

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

这个代码也不能通过，其不能通过的原始数据为：

s = "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaab";

dict = ["a","aa","aaa","aaaa","aaaaa","aaaaaa","aaaaaaa","aaaaaaaa","aaaaaaaaa","aaaaaaaaaa"]

实际上，进行如此修改的话，算法复杂度最大会达到O(2^{s.length()})，因为按照上面的这种输入的话，迭代的次数会超多，最后引发Time Limite Exceeded。

一种正确的解法是什么呢？实际上也是迭代的变种，但是用时间换空间。我们用一个boolean[s.length+1] can临时变量，代表s.substring[0, i]是可以拆的。那么，对于s.substring[0, i+1]来说，如果可以拆，只有两种可能：

1. 对于j < i的某个s.substring(0,j)可拆，且s.substring(j, i)在dict里面；

2. 整个s.substring(0,i)在dict里面。

进一步，这两种情况还可以合并为一种情况：

对于j <= i的某个s.substring(0,j)可拆，且s.substring(j, i)在dict里面，或s.substring(j, i).isEmpty()；

那么，最后的结果是can[length]；

这一算法的算法复杂度是固定的O(n^2)，空间复杂度是O(n)，是一种可行的解决方法。

原始出处请见：http://oj.leetcode.com/discuss/1523/who-can-show-me-a-dp-solution-thanks

代码

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