题目：Word Break
将给定的字符串按照给定的单词表拆分开，判断是否能在给定的单词表中拆分该字符串
单词表中单词不重复，但是可以在字符串中重复出现。
思路：
暴力搜索，只要遍历单词表每次找到与字符串的当前位置往后的n(单词表中当前遍历到的单词长度)的字符重合则表示可以拆分。
这种方法，时间复杂度很高，无法通过。后面还会介绍，代码先略过。
思路：BFS（广度优先搜索）
每次搜索能与当前位置后面n(n是匹配的单词的长度，是可变的)个字符匹配的所有单词，加入队列中，然后修改当前的位置，同时，当前的元素出队；
知道找一个单词使得当前位置修改后到达给定字符串的尾部。
例如：
s = "leetcode" worDict = {"leet","code"} pos = 0->n(8);
初始状态，当pos = 0时，leet与[0,4]的字符匹配，每次需要知道之后pos开始的位置和当前匹配的单词在单词表中的位置，因此我用pair记录上面两个值，将他们入队；
Q = {<0,4>}
然后单词表中没有其他单词匹配，修改当前位置pos = Q.front().second；
修改后的pos < s.size()；则继续匹配单词表，如此循环；
Q = {<0,4>，<1,8>}，此时，找到一个组合，由于只需要判断是否有这样的组合，所有直接返回。
/**广度优先搜索**/ bool LeetCode::wordBreakBFS(string s, vector<string>& wordDict){ if (!wordDict.size())return false; queue<pair<int, int>>Q;//first是单词在词典中的下标，second是当前单词之后开始的位置 auto it = wordDict.cbegin(); while (it != wordDict.cend()){ if ((*it).size() <= s.size() && !s.substr(0, (*it).size()).compare(*it)){//字符串与s的开始部分匹配，找到开始的字符串 if ((*it).size() == s.size())return true;//和一个单词完全匹配 Q.push(make_pair(it - wordDict.cbegin(),(*it).size())); } ++it; } while (!Q.empty()){ auto p = Q.front(); Q.pop(); auto it = wordDict.cbegin(); while (it != wordDict.cend()){//遍历完单词表，找到所有的可能 if ((*it).size() + p.second <= s.size() && !s.substr(p.second, (*it).size()).compare(*it)){//字符串与s的从p.second开始部分匹配 if (p.second + (*it).size() == s.size())return true;//匹配完毕 Q.push(make_pair(it - wordDict.cbegin(), p.second + (*it).size())); } ++it; } } return false; }
但是，上面的方法还是不能通过，超时了，因为给的是vector在找匹配单词上耗时与爆搜是一样的，而且，没有办法减少重复的搜索，所以效率和爆搜差不多，可能是我没有想到什么好的办法减少重复搜索，请知道的人指导一下，总之我没有用这个思路通过。
思路：
考虑到不需要找到具体的路径，我在想动态规划是不是可以呢？
其实是可以的，F(n)表示s字符串中0到n个字符是否能用单词表的单词表示；
F(n) = F(k) && (s.substr(k,n) in wordDict);存在 k in [0 - n]
上面表达式的意思：存在这样的k属于[0,n）使得 F(n) = F(k) 且 (s中k到n的子串在单词表中能找到单词与它匹配)
所以，可以从零开始找到字符串每个位置的对应的F(k)值，然后，返回F(s.size())即可。
注意：
vector<bool>flag表示的F()，它的大小应该是s.size()+1；
每次求end对应位置的F(end)值，需要遍历[0,end)的所有值中是否又满足上面的k（start）
/** 动态规划：F(n) = F(k) && (s.substr(k,n) in wordDict);存在 k in [0 - n] **/ bool LeetCode::wordBreakBF(string s, vector<string>& wordDict){ if (!wordDict.size())return false; sort(wordDict.begin(), wordDict.end()); vector<bool> flag(s.size() + 1,false);//标记每个地方对应的字符串是否能被拼凑出来 flag.at(0) = true; for (int end = 1; end <= s.size(); end++){ for (int start = end - 1; start >= 0; start--){//检查是否存在上面的k，拼凑出[0,end]的字符串 if (flag.at(start)){ string temp = s.substr(start,end - start);//获得从start到end的子串 auto it = wordDict.begin(); while (it != wordDict.end()){//遍历单词表 auto r = temp.compare(*it); if (!r){ flag.at(end) = true; break; } else if(r < 0){//单词表已排序 break; } ++it; } } } } return flag.at(s.size()); }
题目：Word BreakII
在上面的基础上要找出所有可能的不同组合。
单词表中单词不重复，但是可以在字符串中重复出现。
基本上上面的3种方法都可以在这个问题上使用；
思路：
暴力搜索：
定义一个数组记录搜索的路径，同时找到方便回溯时的开始位置，暴力搜索和深度优先很相似；
先找一个可能匹配整个字符串的数组，然后一直匹配到最后，如果不能完全匹配就回溯，此时，要从记录的path的值为起始遍历整个字典。
/** 暴力搜索 Time Limit Exceeded **/ vector<string> LeetCode::wordBreak2(string s, vector<string>& wordDict){ vector<string> retStrs; if (!wordDict.size())return retStrs; int i = 0, pos = 0; vector<int> path; while (pos < s.size()){ for (; i < wordDict.size(); i++){//找到匹配的单词 string& temp = wordDict.at(i); //单词长度不超过剩下的未匹配长度 if (pos + temp.size() <= s.size() && !s.compare(pos, temp.size(), temp)){//temp.compare(s.substr(pos,temp.size())) pos += temp.size(); path.push_back(i); i = 0; break; } } if (pos == s.size()){//s完全匹配成功 auto it = path.cbegin(); string s; while (it != path.cend()){ s.append(wordDict.at(*it)); ++it; if(it != path.cend())s.append(" "); } retStrs.push_back(s); i = wordDict.size(); } if (i == wordDict.size()){//匹配不成功，回溯 if (!path.size())break;//回溯到开始时，还是没有匹配，则跳出循环 i = path.at(path.size() - 1);//不能用back()，他返回的是引用 pos -= wordDict.at(i).size(); path.pop_back(); ++i; } } return retStrs; }
结果超时了。在和前面第一个问题差不多的一个测试用例的地方超时；
思路：BSF
过程和前面差不多，只是，在判断成功的地方合并字符串，而不是返回；同时为了能找回路，需要有辅助数组来记住队列弹出的元素。
同时还要记住后面的元素是因为前面的哪个元素而入队的，即入队的路径。这里不再贴代码。
同样要面对暴力搜索时的超时测试用例。
思路：动态规划
直接在上面动态规划的思想上来修改，即是，在搜索的时候记录下匹配的路径。
我的做法是：定义一个record数组vector<vector<pair<int,int>>>数组的一维的大小和flag相同，他分别对应flag的每个值，
F(n) = F(k) && (s.substr(k,n) in wordDict);存在 k in [0 - n]；k可能有多个值；
record的二维的大小是该位置pos对应的s的子串s.substr(0,pos)匹配的多个组合中的k的值和子串对应的单词表的位置;
first记录flag为true时的单词表的下标,second记录flag为true时的上一个依赖的位置。
于是可通过下面的语句记录路径
record.at(end).push_back(make_pair(it - wordDict.begin(),start));
然后getAllPathFromWB()函数来得到最终的字符串的组合。
该函数getAllPathFromWB()中定义visited数组记录record二维数组中第二维的起始位置，以便回溯的时候从前面的位置接着向后面遍历。
注意：
1.循环是从record的尾部即字符串s的尾部开始的，且该位置没有对应visited的值，因为，它是外循环，不需要记录上一次的遍历的位置。
2.找到一个完整的组合后，删除栈顶元素，并将visited数组的尾部元素加一
3.整个getAllPathFromWB()的思想类似于深度遍历。
void LeetCode::getAllPathFromWB(vector<string>& wordDict, vector<string>& strs, vector<vector<pair<int, int>>>& record){ stack<pair<int,int>>s; vector<int>visited; int i = record.size() - 1; auto it = record.at(i).cbegin(); while (it != record.at(i).cend()){//record的最后元素开始根据记录的下标回溯 s.push((*it)); while (!s.empty()){ auto p = s.top(); if (!p.second){//一条完整路径 vector<pair<int,int>>temp; string str; while (!s.empty()){//出栈并组合单词为句子 auto t = s.top(); s.pop(); str.append(wordDict.at(t.first)); temp.push_back(t); if (!s.empty())str.append(" "); } strs.push_back(str); for (int j = temp.size() - 1; j > 0 ; --j){//入栈，但是去掉栈顶元素(j > 0) s.push(temp.at(j)); } if (visited.size() > 0)++visited.back();//记录最后一个单词的上一个位置的数组加一 } else{ int j = 0; if (visited.size() && visited.size() == s.size()){//visited数组已经存在 j = visited.back(); if (j == record.at(p.second).size()){//record的当前数组是否遍历完 visited.pop_back(); if(visited.size() > 0)++visited.back();//可能回溯到最上面一个句子 s.pop(); continue; } s.push(record.at(p.second).at(j)); } else{//visited数组不存在 s.push(record.at(p.second).at(j)); visited.push_back(j); } } } ++it; } } /** 动态规划：F(n) = F(k) & s.substr(k,n) in wordDict;存在 k in [0 - n] **/ vector<string> LeetCode::wordBreak2BF(string s, vector<string>& wordDict){ vector<string> retStrs; if (!wordDict.size())return retStrs; sort(wordDict.begin(), wordDict.end()); vector<bool> flag(s.size() + 1, false);//标记每个地方对应的字符串是否能被拼凑出来 vector<vector<pair<int,int>>> record(s.size() + 1);//first记录flag为true时的单词表的下标,second记录flag为true时的上一个依赖的位置 flag.at(0) = true; for (int end = 1; end <= s.size(); end++){ for (int start = end - 1; start >= 0; start--){//检查是否存在上面的k，拼凑出[0,end]的字符串 if (flag.at(start)){ string temp = s.substr(start, end - start);//获得从start到end的子串 auto it = wordDict.begin(); while (it != wordDict.end()){//遍历单词表 auto r = temp.compare(*it); if (!r){ flag.at(end) = true; record.at(end).push_back(make_pair(it - wordDict.begin(),start)); break; } else if (r < 0){//单词表已排序 break; } ++it; } } } } if (flag.at(s.size())){ getAllPathFromWB(wordDict,retStrs,record); } return retStrs; }