vector<string> wordBreak(string s, unordered_set<string>& wordDict) {
const int n = s.length();
size_t max_len = 0;
for (const auto& str: wordDict) {
max_len = max(max_len, str.length());
}
vector<bool> canBreak(n + 1, false);
vector<vector<bool>> valid(n, vector<bool>(n, false));
canBreak[0] = true;
for (int i = 1; i <= n; ++i) {
for (int l = 1; l <= max_len && i - l >= 0; ++l) {
if (canBreak[i - l] && wordDict.count(s.substr(i - l, l))) {
valid[i - l][i - 1] = true;
canBreak[i] = true;
}
}
}
vector<string> result, path;
if (canBreak[n]) {
wordBreakHelper(s, valid, 0, &path, &result);
}
return result;
}
vector<string> wordBreak(string s, unordered_set<string> &dict) {
int n = s.length();
string t;
vector<vector<bool>> dp(n, vector<bool>(n, false));
int i, j;
for (i = 0; i < n; i++) {
for (j = i; j < n; j++) {
t = s.substr(i, j-i+1);
if (dict.find(t) != dict.end()) {
dp[i][j] = true;
}
}
}
vector<string> res;
vector<string> path;
wordBreakHelper(s, n-1, dp, path, res);
return res;
}
void wordBreakHelper(const string& s, const vector<vector<bool>>& valid,
int start, vector<string> *path, vector<string> *result) {
if (start == s.length()) {
string tmp;
for (const auto& str : *path) {
tmp += str;
tmp += " ";
}
tmp.pop_back();
result->emplace_back(move(tmp));
return;
}
for (int i = start; i < s.length(); ++i) {
if (valid[start][i]) {
path->emplace_back(s.substr(start, i + 1 - start));
wordBreakHelper(s, valid, i + 1, path, result);
path->pop_back();
}
}
}
// we should search the valid solution from back to front
void wordBreakHelper(string &s, int end, vector<vector<bool>> &inDict,
vector<string> &path, vector<string> &res) {
int n = s.length();
string t;
int i;
if (end == -1) {
for (i = path.size()-1; i >= 0; i--) {
if (i != path.size()-1) {
t += " ";
}
t += path[i];
}
res.push_back(t);
return;
}
for (i = 0; i <= end; i++) {
if (inDict[i][end]) {
t = s.substr(i, end-i+1);
path.push_back(t);
wordBreakHelper(s, i-1, inDict, path, res);
path.pop_back();
}
}
}