Leetcode: 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"

.

最开始试着写了一个简单递归的，时间复杂度过不了。

class Solution {
public:
bool wordBreak(string s, unordered_set<string> &dict) {
string str1, str2;
for (int i = s.size() - 1; i >= 0; --i) {
str1 = s.substr(0, i+1);
str2 = s.substr(i+1);
if (str1.empty() || dict.find(str1) != dict.end()) {
if (str2.empty() || dict.find(str2) != dict.end()) {
return true;
}
else {
if (wordBreak(str2, dict)) {
return true;
}
}
}
}

return false;
}
};

怎么办呢？每次调用workBreak应该可以利用以前计算的结果，正是DP，通过。

class Solution {
public:
bool wordBreak(string s, unordered_set<string> &dict) {
int size = s.size();
int **dp = new int*[size];
for (int i = 0; i < size; ++i) {
dp[i] = new int[size];
memset(dp[i], 0, sizeof(int)*size);
}

return wordBreakUtil(dict, dp, s, 0, size - 1);
}

bool wordBreakUtil(unordered_set<string> &dict, int **dp, string &s, int start, int end) {
if (start > end) {
return true;
}

string str1, str2;
for (int i = end; i >= start; --i) {
str1 = s.substr(start, i - start + 1);
str2 = s.substr(i+1);
if (dict.find(str1) != dict.end()) {
dp[start][i] = 1;
if (str2.empty()) {
return true;
}
else if (dict.find(str2) != dict.end()) {
dp[i+1][end] = 1;
return true;
}
else {
if (dp[i+1][end] == 0) {
if (wordBreakUtil(dict, dp, s, i + 1, end)) {
                           return true;
                       }
                       else {
                           dp[i+1][end] = -1;
                       }
                    }
}
}
else {
dp[start][i] = -1;
}
}

return false;
}
};

两维DP，空间用的比较多，在讨论区看到一个简单些的，用一维DP - dp[i]表示i之后的字符串是否可解。

class Solution {
public:
bool wordBreak(string s, unordered_set<string> &dict) {
int len = s.length();
vector<bool> dp(len + 1,false);
dp[len] = true;

for (int i = len - 1; i >= 0; --i) {
for (int j = i; j < len; ++j) {
string str = s.substr(i, j - i + 1);
if (dict.find(str) != dict.end() && dp[j + 1]) {
dp[i] = true;
break;
}
}
}

return dp[0];
}
};

================= 第二次==============

DP，有点类似求回文的思想，一开始用了两维的数组来保存状态。

class Solution {
public:
bool wordBreak(string s, unordered_set<string> &dict) {
int size = s.size();
vector<vector<bool>> breaks(size, vector<bool>(size, false));
for (int i = size - 1; i >= 0; --i) {
for (int j = i; j < size; ++j) {
if (dict.find(s.substr(i, j-i+1)) != dict.end()) {
breaks[i][j] = true;
if (j + 1 >= size || breaks[j+1][size-1]) {
breaks[i][size-1] = true;
break;
}
}
}
}

return breaks[0][size-1];
}
};

其实呢，一维就够了，只保存某个字符之后的字符串是否可解。

class Solution {
public:
bool wordBreak(string s, unordered_set<string> &dict) {
int size = s.size();
vector<bool> breaks(size, false);
for (int i = size - 1; i >= 0; --i) {
for (int j = i; j < size; ++j) {
if (dict.find(s.substr(i, j-i+1)) != dict.end()) {
if (j + 1 >= size || breaks[j+1]) {
breaks[i] = true;
break;
}
}
}
}

return breaks[0];
}
};

一年之后，还是想半天。。。