LeetCode-139-单词拆分

1、动态规划法

我们可以使用数组$dp[i]$记录字符串$s$的前$i$位能否被拼接出。为了发现$dp$之间的关系，我们定义$j$为$1$到$i$之间的一个值，那么$dp[i]=dp[j]与check(j,i)$。我们遍历每一个可能的$j$，若能在$wordDict$中查找到这个单词即可修改$dp[i]$为$true$。为了方便我们的查找，我们可以将$wordDict$转化为哈希集合加快速度。

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

2、动态规划法优化

上一个动态规划法中由于第二次遍历j的次数过多会花费更长时间，我们可以将遍历j改为遍历wordDict缩短时间。显然当我们想要求解$dp[i]$时，若$dp[i-1]=false$则肯定无法找到相应的单词，故可以直接跳出循环。

class Solution {
public:
    bool wordBreak(string s, vector<string> &wordDict) {
        unordered_set<string> hs;
        for (auto i: wordDict) {
            hs.insert(i);
        }
        vector<bool> dp(s.size() + 1, false);
        dp[0] = true;
        for (int i = 1; i < s.size() + 1; ++i) {
            if (!dp[i - 1]) continue;
            for (auto &str: wordDict) {
                int j = i - 1 + str.size();
                if (j <= s.size() && hs.find(s.substr(i - 1, str.size())) != hs.end()) {
                    dp[j] = true;
                }
            }
        }
        return dp[s.size()];
    }
};

3、字典树

我们先构建字典树，而后在字典树中进行深度遍历。利用数组failMemo记录dfs没搜索到时对应的s中的index。

struct TrieNode {
    TrieNode* next[26];
    bool isEnd;
    TrieNode()
    {
        for (int i = 0; i < 26; i++)
            next[i] = nullptr;
        isEnd = false;
    }
};
class Solution {
    TrieNode* root;
    int failMemo[301]; // 记录dfs中失败时对应的s中的index
public:
    bool wordBreak(string s, vector<string>& wordDict) {
        root = new TrieNode();
        // 建树
        for (auto& word : wordDict)
        {
            TrieNode* p = root;
            for (auto& ch : word)
            {
                if (p->next[ch - 'a'] == nullptr)
                    p->next[ch - 'a'] = new TrieNode();
                p = p->next[ch - 'a'];                   
            }
            p->isEnd = true;            
        }
        return dfs(s, 0);
    }
    bool dfs(string& s, int startPos)
    {
        if (failMemo[startPos] == 1) return false;//1表示没搜索到
        if (startPos == s.size()) return true;
        TrieNode* p = root;        
        for (int i = startPos; i < s.size(); i++)
        {
            if (p->next[s[i] - 'a'] != nullptr)
            {
                p = p->next[s[i] - 'a'];
                if (p->isEnd == true && dfs(s, i+1))
                    return true;   
            }
            else break;   
        }
        failMemo[startPos] = 1;
        return false;
    }
};