139單詞拆分

題目

給定一個非空字符串 s 和一個包含非空單詞列表的字典 wordDict，判定 s 是否可以被空格拆分爲一個或多個在字典中出現的單詞。
說明：
拆分時可以重複使用字典中的單詞。
你可以假設字典中沒有重複的單詞。
示例 1：
輸入: s = “leetcode”, wordDict = [“leet”, “code”]
輸出: true
解釋: 返回 true 因爲 “leetcode” 可以被拆分成 “leet code”。
示例 2：
輸入: s = “applepenapple”, wordDict = [“apple”, “pen”]
輸出: true
解釋: 返回 true 因爲 “applepenapple” 可以被拆分成 “apple pen apple”。
注意你可以重複使用字典中的單詞。
示例 3：
輸入: s = “catsandog”, wordDict = [“cats”, “dog”, “sand”, “and”, “cat”]
輸出: false

來源：力扣（LeetCode）
鏈接：https://leetcode-cn.com/problems/word-break。

代碼及分析

方法一：遞歸

這道題目可以採用遞歸的方法進行求解。從字符串的首字符開始，依次向後遍歷，當找到存在於字典當中的單詞時，將其拆分爲單詞+字符串，然後遞歸對所得字符串求解。但是單純這樣去求解會有大量的重複極速三，造成超時的問題，故我們可以加入數組memory來保存已經計算的結果，每次計算前可以看是否存在於memory中，存在則不需要再次計算。 memory[start] 表示字符串 [i, n] 是否可拆分。
wordDict： cat, cats, and, sand, dog
s ： catsanddog 長爲10
第一層：
start = 0
$\quad\quad\quad$i = 1 $\quad$c
$\quad\quad\quad$i = 2 $\quad$ca
$\quad\quad\quad$i = 3 $\quad$cat 存在 ③返回1
$\quad\quad\quad$第二層 ：
$\quad\quad\quad$start = 3
$\quad\quad\quad\quad\quad\quad$i = 4 $\quad$s
$\quad\quad\quad\quad\quad\quad$i = 5 $\quad$sa
$\quad\quad\quad\quad\quad\quad$i = 6 $\quad$san
$\quad\quad\quad\quad\quad\quad$i = 7 $\quad$sand 存在 ②返回1
$\quad\quad\quad\quad\quad\quad$第三層 ：
$\quad\quad\quad\quad\quad\quad$start = 7
$\quad\quad\quad\quad\quad\quad\quad\quad\quad$i = 8 $\quad$d
$\quad\quad\quad\quad\quad\quad\quad\quad\quad$i = 9 $\quad$do
$\quad\quad\quad\quad\quad\quad\quad\quad\quad$i = 10 $\quad$dog 存在 ①返回1
返回結果順序爲①->②->③，最終結果爲true。

class Solution {
public:
    bool wordBreak(string s, vector<string>& wordDict) {
        if(s.empty())
            return true;
        if(wordDict.empty())
            return false;
        int l = s.size();
        // 方便後續查看對應單詞在字典中是否存在
        set<string> dict(wordDict.begin(),wordDict.end());
        vector<int> memory(l,-1);
        return fun(s,dict,memory,0);
        
    }
    bool fun(string s, set<string> dict, vector<int> &memory, int start)
    {
        if(start >= s.size())
            return true;
        if(memory[start] != -1)
            return memory[start];
        for(int i = start+1; i <= s.size(); i++)
        {
            if(dict.count(s.substr(start,i-start)) && fun(s,dict,memory,i))
                return memory[start] = 1;
        }
        return memory[start] = 0;
    }
    
};

複雜度：

時間複雜度： O(n^2) 。
空間複雜度： O(n) 。

方法二：動態規劃法

這道題還可以用動態規劃的方法去求解。
首先我們建立一個以爲數組dp，其中dp[i]表示字符串[0,i)是否可以拆分，包含空字符串，故可以初始化dp[0] = true;
我們可以遍歷字符串[0,i)，將其分爲兩部分，[0,j) 以及[j, i)，故可以得出動態轉移方程爲：
dp[i] = dp[j] && dict.count(s.substr(j,i-j))。

bool wordBreak(string s, vector<string>& wordDict) {
        if(s.empty())
            return true;
        if(wordDict.empty())
            return false;
        int l = s.size();
        set<string> dict(wordDict.begin(),wordDict.end());
        vector<int> dp(l+1,0);
        dp[0] = 1;
        for(int i = 1; i <= l; i++)
        {
            for(int j = 0; j < i; j++)
            {
                if(dp[j] && dict.count(s.substr(j,i-j)))
                {
                    dp[i] = 1;
                    break;
                }  
            }
        }
        return dp[l];
    }

複雜度：

時間複雜度： O(n^2) ；
空間複雜度： O(n) 。

方法三：廣度優先搜索

上述我們採用了遞歸的方法對該問題進行了求解，實際上這就是DFS方法。
那麼同樣BFS應該也是可以求解的。
廣度優先搜索法，也就是我們不會一次性直接遍歷到最底端，而是每一步將整個字符串拆分爲單詞+字符串的形式，然後再繼續對拆分得到的字符串進行判斷（這裏與DFS不同的是，DFS一旦找到一各符合要求的單詞，便對後續的字符串進行求解，而BFS是先將當前可以得到的單詞全部求解出來，然後分別求解各個單詞對應的後續字符串）。建立一個queue，用於保存可拆分的位置。
這裏我們可以建立一個memory數組，用於保存該位置是否拆分過。
舉例說明：
wordDict： cat, cats, and, sand, dog
s ： catsanddog 長爲10
第一次循環：
q : 0;
start = 0
$\quad\quad\quad$i = 1 $\quad$c
$\quad\quad\quad$i = 2 $\quad$ca
$\quad\quad\quad$i = 3 $\quad$cat $\quad$q : 3
$\quad\quad\quad$i = 4 $\quad$cats $\quad$q : 3, 4
i = 5， 6， 7… …
第二次循環：
q : 3, 4
start = 3
$\quad\quad\quad$i = 4 $\quad$s
$\quad\quad\quad$i = 5 $\quad$sa
$\quad\quad\quad$i = 6 $\quad$san $\quad$
$\quad\quad\quad$i = 7 $\quad$sand $\quad$q : 4, 7
i = 7, 8 … …
第三次循環：
q : 4， 7
start = 4
$\quad\quad\quad$i = 5 $\quad$a
$\quad\quad\quad$i = 6 $\quad$an
$\quad\quad\quad$i = 7 $\quad$and $\quad$q : 7, 7
i = 8 , 9… …
第四次循環：
q : 7， 7
start = 7
$\quad\quad\quad$i = 8 $\quad$d
$\quad\quad\quad$i = 9 $\quad$do
$\quad\quad\quad$i = 10 $\quad$dog $\quad$q : 7, 10
這是 i = l，故返回true。
需要注意的一點是，在這個跟例子中如果還沒有到字符串結尾，那麼下一次循環中，start = 7，但顯然這一種情況將會和第四次循環完全相同，屬於重複計算，數組memory便是爲了解決這個問題而存在的，我們將每一次拆分位置保存在memory當中，在每一次循環初，我們要首先判斷該位置是否已經被處理過。
其廣度搜索示意圖如下：

 bool wordBreak(string s, vector<string>& wordDict) {
        if(s.empty())
            return true;
        if(wordDict.empty())
            return false;
        int l = s.size();
        set<string> dict(wordDict.begin(),wordDict.end());
        queue<int> q;
        q.push(0);
        vector<int> memory(l,0);
        while(!q.empty())
        {
            int start = q.front();
            q.pop();
            if(memory[start])
                continue;
            for(int i = start+1; i <= l; i++)
            {
                if(dict.count(s.substr(start,i-start)))
                {
                    q.push(i);
                    if(i == l)
                        return true;
                }
            }
            memory[start] = 1;
        }
        return false;
    
    }

複雜度：

時間複雜度： O(n^2) ；
空間複雜度： O(n) 。