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 = ; i < len; i++) {
             vector<string> words;

             if (dict.find(s.substr(, i + )) != dict.end())
                 words.push_back(s.substr(, i + ));

             for (int j = ; j <= i; j++) {
                 vector<string> pres = record[j - ];
                 string post = s.substr(j, i - j + );
                 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 - ])
             que.push(pair<int, string>(len - r.length(), r));
         while (!que.empty()) {
             pair<int, string> p = que.front();
             que.pop();
             if (p.first <= )
                 res.push_back(p.second);
             else {
                 for (auto w : record[p.first - ])
                     que.push(pair<int, string>(p.first - w.length(), w + " " + p.second));
             }
         }

         return res;
 }