feat: add solutions to lc problem: No.0139

No.0139.Word Break

Author: yanglbme

solution/0100-0199/0139.Word Break/README.md

@@ -58,6 +58,12 @@ $dp[i]$ 表示前 $i$ 个字符组成的字符串 $s[0...i-1]$ 能否拆分成
 
 时间复杂度 $O(n^2)$。
 
+**方法二：前缀树 + 记忆化搜索**
+
+根据 $wordDict$ 构建前缀树 $trie$，然后枚举前缀 $s[:i]$ 作为第一个单词，若在 $trie$ 中，则递归搜索 $s[i:]$。
+
+若存在满足条件的拆分方案，返回 $true$。
+
 <!-- tabs:start -->
 
 ### **Python3**
@@ -79,6 +85,42 @@ class Solution:
         return dp[-1]
 ```
 
+```python
+class Trie:
+    def __init__(self):
+        self.children = [None] * 26
+        self.is_end = False
+    
+    def insert(self, w):
+        node = self
+        for c in w:
+            idx = ord(c) - ord('a')
+            if node.children[idx] is None:
+                node.children[idx] = Trie()
+            node = node.children[idx]
+        node.is_end = True
+    
+    def search(self, w):
+        node = self
+        for c in w:
+            idx = ord(c) - ord('a')
+            if node.children[idx] is None:
+                return False
+            node = node.children[idx]
+        return node.is_end
+
+class Solution:
+    def wordBreak(self, s: str, wordDict: List[str]) -> bool:
+        @cache
+        def dfs(s):
+            return not s or any(trie.search(s[:i]) and dfs(s[i:]) for i in range(1, len(s) + 1))
+        
+        trie = Trie()
+        for w in wordDict:
+            trie.insert(w)
+        return dfs(s)
+```
+
 ### **Java**
 
 <!-- 这里可写当前语言的特殊实现逻辑 -->
@@ -103,6 +145,66 @@ class Solution {
 }
 ```
 
+```java
+class Trie {
+    Trie[] children = new Trie[26];
+    boolean isEnd;
+
+    void insert(String w) {
+        Trie node = this;
+        for (char c : w.toCharArray()) {
+            c -= 'a';
+            if (node.children[c] == null) {
+                node.children[c] = new Trie();
+            }
+            node = node.children[c];
+        }
+        node.isEnd = true;
+    }
+
+    boolean search(String w) {
+        Trie node = this;
+        for (char c : w.toCharArray()) {
+            c -= 'a';
+            if (node.children[c] == null) {
+                return false;
+            }
+            node = node.children[c];
+        }
+        return node.isEnd;
+    }
+}
+
+class Solution {
+    private Trie trie = new Trie();
+    private Map<String, Boolean> memo = new HashMap<>();
+
+    public boolean wordBreak(String s, List<String> wordDict) {
+        for (String w : wordDict) {
+            trie.insert(w);
+        }
+        return dfs(s);
+    }
+
+    private boolean dfs(String s) {
+        if (memo.containsKey(s)) {
+            return memo.get(s);
+        }
+        if ("".equals(s)) {
+            return true;
+        }
+        for (int i = 1; i <= s.length(); ++i) {
+            if (trie.search(s.substring(0, i)) && dfs(s.substring(i))) {
+                memo.put(s, true);
+                return true;
+            }
+        }
+        memo.put(s, false);
+        return false;
+    }
+}
+```
+
 ### **C++**
 
 ```cpp
@@ -129,6 +231,64 @@ public:
 };
 ```
 
+```cpp
+class Trie {
+private:
+    vector<Trie*> children;
+    bool isEnd;
+public:
+    Trie() : children(26), isEnd(false) {}
+
+    void insert(string word) {
+        Trie* node = this;
+        for (char c : word)
+        {
+            c -= 'a';
+            if (!node->children[c]) node->children[c] = new Trie();
+            node = node->children[c];
+        }
+        node->isEnd = true;
+    }
+
+    bool search(string word) {
+        Trie* node = this;
+        for (char c : word)
+        {
+            c -= 'a';
+            if (!node->children[c]) return false;
+            node = node->children[c];
+        }
+        return node->isEnd;
+    }
+};
+
+class Solution {
+public:
+    Trie* trie = new Trie();
+    unordered_map<string, bool> memo;
+
+    bool wordBreak(string s, vector<string>& wordDict) {
+        for (auto w : wordDict) trie->insert(w);
+        return dfs(s);    
+    }
+
+    bool dfs(string s) {
+        if (memo.count(s)) return memo[s];
+        if (s == "") return true;
+        for (int i = 1; i <= s.size(); ++i)
+        {
+            if (trie->search(s.substr(0, i)) && dfs(s.substr(i)))
+            {
+                memo[s] = true;
+                return true;
+            }
+        }
+        memo[s] = false;
+        return false;
+    }
+};
+```
+
 ### **Go**
 
 ```go
@@ -152,6 +312,39 @@ func wordBreak(s string, wordDict []string) bool {
 }
 ```
 
+```go
+type Trie struct {
+	children [26]*Trie
+	isEnd    bool
+}
+
+func newTrie() *Trie {
+	return &Trie{}
+}
+func (this *Trie) insert(word string) {
+	node := this
+	for _, c := range word {
+		c -= 'a'
+		if node.children[c] == nil {
+			node.children[c] = newTrie()
+		}
+		node = node.children[c]
+	}
+	node.isEnd = true
+}
+func (this *Trie) search(word string) bool {
+	node := this
+	for _, c := range word {
+		c -= 'a'
+		node = node.children[c]
+		if !node.isEnd {
+			return false
+		}
+	}
+	return true
+}
+```
+
 ### **C#**
 
 ```cs