Leetcode#140 Word Break II

原题地址

动态规划题

令s[i..j]表示下标从i到j的子串，它的所有分割情况用words[i]表示

假设s[0..i]的所有分割情况words[i]已知。则s[0..i+1]的分割情况words[i+1] = words[k] + s[k+1..i+1]，其中（有三个条件要满足）(1) 0 <= k <= i，(2) words[k]非空，(3) s[k+1..i+1]在字典中。

根据这个递推公式求解，有两种枚举方式：

1. 对于每个待求解的位置i，从0到i枚举所有的k，然后检验words[k]是否非空，以及s[k+1..i+1]是否在字典中

2. 对于每个待求解的位置i，枚举字典中的所有单词w，计算出k=i-w.length，然后检验是否0 <= k <= i，以及s[k+1..i+1]和w是否相等

两种方式各有优缺点，如果枚举k，则当原串s特别长的时候，效率比较低；如果枚举字典，当字典里的单词很多的时候，效率比较低。

感觉第一种方式（枚举k）更加自然一些。

最后需要注意的是，最坏情况下枚举的结果是2^n数量级的，此时如果把每个s[0..i]的所有分割情况都保存下来，内存会爆掉。所以只保存s[0..i]分割后的最后一个单词，最后用广搜构造所有解。

代码：

注：上面所说的"words"对应下面代码中的"record"

vector<string> wordBreak(string s, unordered_set<string> &dict) {
        map<int, vector<string> > record;
        int len = s.length();
        
        // DP枚举
        for (int i = 0; i < len; i++) {
            vector<string> words;
            
            if (dict.find(s.substr(0, i + 1)) != dict.end())
                words.push_back(s.substr(0, i + 1));
                
            for (int j = 1; j <= i; j++) {
                vector<string> pres = record[j - 1];
                string post = s.substr(j, i - j + 1);
                if (!pres.empty() && dict.find(post) != dict.end()) {
                    words.push_back(post);
                }
            }
            
            record.insert(pair<int, vector<string> >(i, words));
        }
        
        // BFS构造
        vector<string> res;
        queue<pair<int, string> > que;
        for (auto r : record[len - 1])
            que.push(pair<int, string>(len - r.length(), r));
        while (!que.empty()) {
            pair<int, string> p = que.front();
            que.pop();
            if (p.first <= 0)
                res.push_back(p.second);
            else {
                for (auto w : record[p.first - 1])
                    que.push(pair<int, string>(p.first - w.length(), w + " " + p.second));
            }
        }
        
        return res;
}