LeetCode 139. Word Break【KMP+动态规划】⭐⭐⭐⭐⭐

题目描述

给定一个单词和一个词典，看这个单词能不能由词典里面的单词构成。

知识点

动态规划？我用的是 KMP+dp数组 的方式

结果

实现

码前思考

确实没有想到怎么用纯动规来解答这个题目。。。所以就动起了KMP的歪脑筋

1. 首先，需要明确的是，如果能够被拆分，那么肯定是由s中匹配的word构成的，所以，我们不妨先找出s中所有匹配的word，然后记录这些word在s的起点和终点；
2. 得到s中所有的匹配的word的起点和终点之后，将他们按照起点进行从小到大排序，然后进行遍历，就是dp的思想了；
3. 对于每一个匹配的word，我们查看这个word.start之前的word.start-1是否被匹配，如果被匹配，则设置s的word.end位置被匹配啦。
4. 最后检查s.size()-1是否被匹配就好啦~~

其实就两大步——找到s中所有的匹配，然后检查这些匹配中是否存在一个序列能够组成s

代码实现

//先对每个子串来一遍KMP，然后再来一遍排序选择？
struct node{
    int start;
    int end;
    node(){}
    node(int s,int e){
        start = s;
        end = e;
    }
};
class Solution {
public:
    vector<node> matchArr;

    static bool cmp(node a,node b){
        return a.start < b.start;
    }

    void getNex(string& word,vector<int> &nex){//记得传地址
        //初始化
        nex[0]=-1;
        int j=-1;
        for(int i=1;i<word.size();i++){
            cout<<i<<endl;
            while(j!=-1 && word[i]!=word[j+1]){
                j = nex[j];
            }
            if(word[i]==word[j+1]){
                j++;
            }
            nex[i]=j;
        }
    }

    void getMatch(string& word,string& s,vector<int> &nex){
        int j=-1;
        for(int i=0;i<s.size();i++){
            while(j!=-1 && s[i]!=word[j+1]){
                j = nex[j];
            }
            if(s[i]==word[j+1]){
                j++;
            }
            if(j==word.size()-1){
                //先记录一下
                node tmp(i-word.size()+1,i);
                //cout<<word<<" start: "<<tmp.start<<" end: "<<tmp.end<<endl;
                matchArr.push_back(tmp);
                //把它回到之前的一个状态
                j = nex[j];
            }
        }
    }

    bool wordBreak(string s, vector<string>& wordDict) {
        //对于每一个wordDict里面的数字进行一次KMP，找到所有匹配的位置！
        for(int i=0;i<wordDict.size();i++){
            string word = wordDict[i];
            vector<int> nex(word.size());
            //得到next数组
            getNex(word,nex);
            //得到next数组之后再去匹配
            getMatch(word,s,nex);
        }
        
        //然后对数组进行按照start从小到大排序
        sort(matchArr.begin(),matchArr.end(),cmp);

        //定义一个匹配数组进行检查
        vector<bool> dp(s.size(),false);

        //遍历数组
        for(int i=0;i<matchArr.size();i++){
            int start = matchArr[i].start;
            int end  = matchArr[i].end;
            if(start==0){
                //直接进行设置
                dp[end]=true;
            }else{
                if(dp[start-1]==true){
                    dp[end]=true;
                }
            }
        }

        return dp[s.size()-1];
    }
};

码后反思

1. 我居然能够默写KMP算法了。。。我好感动😭（虽然我还是不懂其中的原理，后面要复习鸭~~）
2. 其实我看官方题解上并未使用KMP啦，i’m not typical~~这个dp有点妙呀，属于的是序列型的dp，使用到的了一个非常重要的东西，就是set来控制匹配（C++unordered_set查找时间复杂度为O(1)啦，因为使用的是hash嘛，set就不是了，因为它使用的是红黑树），这样就降低了时间复杂度了，妙啊！
   
   

二刷反思

动态规划的解法如下：
采用的方法是不断地求前缀匹配的方式，特别地妙，涉及到了动态规划集合划分的思想！！！
「手画图解」3种方法及优化：DFS、BFS、动态规划

代码如下：

//采用动态规划的解法进行
class Solution {
public:
    bool wordBreak(string s, vector<string>& wordDict) {
        unordered_set<string> st;
        for(string str : wordDict){
            st.insert(str);
        }
        int len = s.size();
        s = " "+s;  //移动一位，这样好写一些
        
        vector<bool> dp(len+1,false);//代表是否匹配
        //接下来进行dp的初始化
        dp[0]=true;
        for(int i=1;i<=len;i++){
            for(int j=1;j<=i;j++){
                if(dp[j-1]==true && st.find(s.substr(j,i-j+1))!= st.end()){
                    dp[i]=true;
                    break;
                }
            }
        }

        return dp[len];
    }
};