Leetcode OJ: Word Break I/II

又是专题二重奏的节奏。这回的题目是word break，其实就是自然语言处理中的分词，不过说实话，从自然语言处理课学来的方法是前向最大匹配或者是后向最大匹配，又或者是两者结合啊，像这个貌似不一定按着语言规则走的，所以不能用自然语言处理中通过统计的方法去进行剪技，那怎么办呢？

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

第一反应，递归实现的穷举。果不其然，Time Limit Exceed。贴下懒人的代码：

class Solution {
public:
    bool wordBreak(string s, unordered_set<string> &dict) {
        string::iterator is = s.begin();
        int count = 0;
        while (is != s.end()) {
            is++;
            count++;
            if (dict.count(s.substr(0, count)) > 0 && wordBreak(s.substr(count), dict))
                return true;
        }
        return false;
    }
};

然后，想想自然语言处理课都讲过什么了，发现当年貌似是要统计字典最大长度什么的，这样比较就可以少一些，于是就在前面加了段统计单词最大长度的代码，然后满心欢喜地submit了，然后了果断又TLE了。再贴下代码：

class Solution {
public:
    bool wordBreak(string s, unordered_set<string> &dict) {
        string::iterator is = s.begin();
        int count = 0;
 6         int maxSize = 0;
 7         for (auto it = dict.begin(); it != dict.end(); ++it) {
 8             if ((*it).size() > maxSize)
 9                 maxSize = (*it).size();
10         }
        while (is != s.end() && count < maxSize) {
            is++;
            count++;
            if (dict.count(s.substr(0, count)) > 0 && wordBreak(s.substr(count), dict))
                return true;
        }
        return false;
    }
};

LZ痛定思痛，休息了两天，然后跟同学讨论了下这题，是不是可以用动态规划的方法剪技？嗯~ 终于有思路了。

LZ从数组尾部开始比较啊，其实从头部也是可以的，思路差不多。

我们先定义一个数组flag[0..n]用于表示以位置i (0..n-1)为起点，到结尾是否可达，即能成功分词。

若我们从尾部开始考虑，则当在位置i时，i后存在一个j，满足

1) i, j间的子串在字典中

2) 位置j到结尾是可达的

那么，在位置i点则可达，否则不可达，即

flag[i] = exists(dict.exists(substr(i, j))  && flag[j] )，其中i < j <= i + maxSize

从尾部一直记录到头部的时候就知道头部是否可达了~

代码如下：

class Solution {
public:
    bool wordBreak(string s, unordered_set<string> &dict) {
        if (s.empty() || dict.empty())
            return false;
        int maxSize = 0;
        for (auto it = dict.begin(); it != dict.end(); ++it) {
            if ((*it).size() > maxSize)
                maxSize = (*it).size();
        }
        int size = s.size();
        // 注意是size+1的长度，最后一个设为true
        vector<bool> flag(size + 1, false);
        flag[size] = true;
        
        for (int i = size - 1; i >= 0; --i) {
            bool tmp = false;
            for (int j = 1; j <= maxSize && i + j <= size; ++j) {
                // 有些小trick，先判断可达，再判断是否在字典中，会快些
                if (flag[i + j] && dict.find(s.substr(i, j)) != dict.end()) {
                    tmp = true;
                    break;
                }
            }
            flag[i] = tmp;
        }
        
        return flag[0];
    }
};

时间复杂度为O(maxSize * n)，空间复杂度为n

这还仅仅是判断是否存在，那如果是需要找出所有路径呢？这才是我们分词的最终目的啊。

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

有了上面的经验，当然做起来就容易很多了，从原来的存是否可达变成存放路径就可以了~ 直接上代码吧~

class Solution {
public:
    vector<string> wordBreak(string s, unordered_set<string> &dict) {
        if (s.empty() || dict.empty())
            return vector<string>();
        int maxSize = 0;
        for (auto id = dict.begin(); id != dict.end(); ++id) {
            if ((*id).size() > maxSize)
                maxSize = (*id).size();
        }
        
        int size = s.size();
        // 存之前的组合，最后一个设为空串
        vector< vector<string> > ret(size + 1, vector<string>());
        ret[size] = vector<string>(1, "");
        
        for (int i = size - 1; i >= 0; --i) {
            for (int j = 1; j <= maxSize && i + j <= size; ++j) {
                string sub = s.substr(i, j);
                if (!ret[i + j].empty() && dict.find(sub) != dict.end()) {
                    for (vector<string>::iterator isv = ret[i + j].begin();
                        isv != ret[i + j].end(); ++isv)
                    {
                        // 处理非空串时
                        if (!(*isv).empty())
                            ret[i].push_back(sub + " " + (*isv));
                        else // 空串时也需要push
                            ret[i].push_back(sub);
                    }
                }
            }
        }
        return ret[0];
    }
};

这里就A了，但这里其实是有问题的，时间复杂度是O(maxSize*n)，空间复杂度是O(n!)。

当我们的字符串很长的时候，如果我们把一路的组合都记录下来了，那会占用很大的内存，有没有优化的方法？

这里LZ想到的方法是用循环队列。我们发现当前位置i，进行比较的范围最大只到其前面的maxSize个偏移的位置，再后面的是不需要比较的。

那么用一个定长的循环队列就能很好地完成这个事情了，空间复杂度也能降不少。代码如下：

class Solution {
public:
    vector<string> wordBreak(string s, unordered_set<string> &dict) {
        if (s.empty() || dict.empty())
            return vector<string>();
        int maxSize = 0;
        for (auto id = dict.begin(); id != dict.end(); ++id) {
            if ((*id).size() > maxSize)
                maxSize = (*id).size();
        }
        
        int size = s.size();
        // 大小只有maxSize
        vector< vector<string> > ret(maxSize, vector<string>());
        // 从第0个开始
        ret[0] = vector<string>(1, "");
        int pos = 0;
        for (int i = size - 1; i >= 0; --i) {
            // 存i位置的组合
            vector<string> tmp;
            for (int j = 1; j <= maxSize && i + j <= size; ++j) {
                string sub = s.substr(i, j);
                // 简易的循环队列
                int cur = (pos + j - 1) % maxSize;
                if (!ret[cur].empty() && dict.find(sub) != dict.end()) {
                    for (vector<string>::iterator isv = ret[cur].begin();
                        isv != ret[cur].end(); ++isv)
                    {
                        if (!(*isv).empty())
                            tmp.push_back(sub + " " + (*isv));
                        else
                            tmp.push_back(sub);
                    }
                }
            }
            // 把得到的组合置于开始
            if (--pos < 0) {
                pos += maxSize;
            }
            ret[pos] = tmp;
        }
        return ret[pos];
    }
};

总的来说，空间占用是有所减少的，但还是不少。跟同学再讨论了一翻，提供了个方案：

1. 利用以上word break I中的flag数组，再存一个用于表示每一个位置上可达的话需要向前移的步数step数组

2. 利用step数组，进行深搜，通过回溯的方法得出最后的路径。

 这一方案LZ没实现，有兴趣的同学们可以自己试下。