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"

.

之前好像是写过这个题目的解题报告，说实话这个题目我实在是理解了好久。今天花了一整天时间研究这个题目，最终自己给出了一个O（n^3）的dp算法，然后在Discuss中看了各路大神们的算法，我真是太。。。

话不多说，正题：

思路1：dfs

深度优先搜素，对于字符串s[0,..,n]每次判断其前缀是否可以按照字典所给出的单词进行分词操作，递归进行，分词之字符串尾时返回，代码如下：

//递归求解每次检查当前字串前缀，如果可分则继续深度查询
class Solution {
public:
bool wordBreak(string s, unordered_set<string> &dict) {
issegment=false;
wordBreak(s,0,dict);
return issegment;
}
void wordBreak(const string &s,int pos,unordered_set <string> &dict){
if(pos==s.size()) issegment=true;
if(issegment) return;
for(int i=pos;i<s.size();i++){
auto iter=dict.find(s.substr(pos,i-pos+1));
if(iter!=dict.end()){
wordBreak(s,i+1,dict);
}
}
}
private:
bool issegment;
};

dfs有太多的重复计算，具体图例在我第一遍作的时候就已经画图了，因此想到dp：

思路2：dp

我自己的想法是，对于字符串s[i,..,j]是否可以按照字典所给单词进行分词，存在以下两种情况：

1) s[i,..,j]在字典dict中；

2) 至少存在一个k（i<k<j）使得s[i,..,k]和s[k+1,..,j]都可以被分词；

为此使dp[i][j]表示s[i,..,j]是否可以被分词，递归式如下：

dp[i][j] = true if dictContain(s[i,..,j]) or (dictContain(s[i,..,k])&&dictContain(s[k+1,..,j]))

= false other

由此，有点类似于矩阵连乘问题，共有O(n^2)个子问题，每个子问题有包括O(n)种选择，算法时间复杂度O(n^3),空间复杂度O(n^2)。

代码如下:

#include <string>
#include <vector>
using namespace std;

class Solution{
public:
bool wordBreak(string s,unordered_set <string> &dict){
int len=s.size();
if(!len){
return false;
}

vector <vector <bool> > dp(len,vector <bool>(len,0));

//initialize dp
for(int i=0;i<len;i++){
dp[i][i]=dictContain(s.substr(i,1),dict);
}
//dp
for(int l=2;l<=len;l++){
for(int beg=0;beg+l<=len;beg++){
dp[beg][beg+l-1]=dictContain(s.substr(beg,l),dict);
if(dp[beg][beg+l-1]){continue;}
for(int k=1;k<l;k++){
dp[beg][beg+l-1]=dp[beg][beg+k-1]&&dp[beg+k][beg+l-1];
if(dp[beg][beg+l-1]) break;
}
}
}
return dp[0][len-1];
}
bool dictContain(const string &s,const unordered_set <string> &dict){
auto iter=dict.find(s);
if(auto==dict.end()){
return false;
}
return true;
}
}

思路3：dp+dfs

看了一位大神的代码，总结一下，发现其实换个角度，我们只需要考虑s[0,..,i]是否可以被分词，s[0,..,j]可以被分词的充分必要条件是:

1）存在一个k(0<k<i)使得s[0,..,k]可以被分词并且s.substr(k+1,j)是字典dict中的单词 OR

2）s[0,..,j]本身就在字典dict中；

由此每个子问题的子问题变为只有1个，同时对于子问题的选择有O(n)种，为此使用数组

dp[0,s.size()]记录分词信息，其中dp[i]表示s[0,..,i]是否可以被分词，

dp[i] = true if dictContain(s[0,..,i]) or ((dictContain(s[k+1,..,j]))&&dp[k])

最终结果为dp[s.size()-1],时间复杂度O(n^2),空间O(n),代码如下：

class Solution{
public:
bool wordBreak(string s,unordered_set <string> &dict){
int len=s.size();
vector <bool> dp(len+1,0);
dp[0]=true;
for(int i=1;i<=len;i++){
//check if s.substr(0,i) can be broken
string str=s.substr(0,i);
for(int j=0;j<i;j++){
if(dp[j]&&dictContain(str,dict)){
dp[i]=true;
break;
}
str.erase(str.begin());
}
}
return dp[len];
}
bool dictContain(string s,const unordered_set <string> &dict){
auto iter=dict.find(s);
if(iter!=dict.end()){
return true;
}
return false;
}
} ;

最后说一句忘了在哪个文章中看到的一句话：dp真是一个神奇的东西，只有你自己写了才能体会到，dp代码的简洁美