feat: add solutions to lc problem: No.0139. Word Break

yanglbme · yanglbme · commit ea7aca5d22bd · 2021-07-13T13:49:15.000+08:00
diff --git a/README.md b/README.md
@@ -177,6 +177,7 @@
 - [买卖股票的最佳时机 III](./solution/0100-0199/0123.Best%20Time%20to%20Buy%20and%20Sell%20Stock%20III/README.md)
 - [最佳买卖股票时机含冷冻期](./solution/0300-0399/0309.Best%20Time%20to%20Buy%20and%20Sell%20Stock%20with%20Cooldown/README.md)
 - [买卖股票的最佳时机含手续费](./solution/0700-0799/0714.Best%20Time%20to%20Buy%20and%20Sell%20Stock%20with%20Transaction%20Fee/README.md)
+- [单词拆分](./solution/0100-0199/0139.Word%20Break/README.md)
 - [接雨水](./solution/0000-0099/0042.Trapping%20Rain%20Water/README.md)
 - [礼物的最大价值](./lcof/面试题47.%20礼物的最大价值/README.md)
 - [最小路径和](./solution/0000-0099/0064.Minimum%20Path%20Sum/README.md)
diff --git a/README_EN.md b/README_EN.md
@@ -171,6 +171,7 @@ Complete solutions to [LeetCode](https://leetcode.com/problemset/all/), [LCOF](h
 - [Best Time to Buy and Sell Stock III](./solution/0100-0199/0123.Best%20Time%20to%20Buy%20and%20Sell%20Stock%20III/README_EN.md)
 - [Best Time to Buy and Sell Stock with Cooldown](./solution/0300-0399/0309.Best%20Time%20to%20Buy%20and%20Sell%20Stock%20with%20Cooldown/README_EN.md)
 - [Best Time to Buy and Sell Stock with Transaction Fee](./solution/0700-0799/0714.Best%20Time%20to%20Buy%20and%20Sell%20Stock%20with%20Transaction%20Fee/README_EN.md)
+- [Word Break](./solution/0100-0199/0139.Word%20Break/README_EN.md)
 - [Trapping Rain Water](./solution/0000-0099/0042.Trapping%20Rain%20Water/README_EN.md)
 - [Minimum Path Sum](./solution/0000-0099/0064.Minimum%20Path%20Sum/README_EN.md)
 - [Decode Ways](./solution/0000-0099/0091.Decode%20Ways/README_EN.md)
diff --git a/solution/0100-0199/0139.Word Break/README.md b/solution/0100-0199/0139.Word Break/README.md
@@ -36,27 +36,131 @@
 <strong>输出:</strong> false
 </pre>
 
-
 ## 解法
 
 <!-- 这里可写通用的实现逻辑 -->
 
+动态规划法。
+
+`dp[i]` 表示前 i 个字符组成的字符串 `s[0...i-1]` 能否拆分成若干个字典中出现的单词。
+
 <!-- tabs:start -->
 
 ### **Python3**
 
 <!-- 这里可写当前语言的特殊实现逻辑 -->
 
 ```python
-
+class Solution:
+    def wordBreak(self, s: str, wordDict: List[str]) -> bool:
+        words = set(wordDict)
+        n = len(s)
+        dp = [False] * (n + 1)
+        dp[0] = True
+        for i in range(1, n + 1):
+            for j in range(i):
+                if dp[j] and s[j:i] in words:
+                    dp[i] = True
+                    break
+        return dp[n]
 ```
 
 ### **Java**
 
 <!-- 这里可写当前语言的特殊实现逻辑 -->
 
 ```java
+class Solution {
+    public boolean wordBreak(String s, List<String> wordDict) {
+        Set<String> words = new HashSet<>(wordDict);
+        int n = s.length();
+        boolean[] dp = new boolean[n + 1];
+        dp[0] = true;
+        for (int i = 1; i <= n; ++i) {
+            for (int j = 0; j < i; ++j) {
+                if (dp[j] && words.contains(s.substring(j, i))) {
+                    dp[i] = true;
+                    break;
+                }
+            }
+        }
+        return dp[n];
+    }
+}
+```
+
+### **C++**
+
+```cpp
+class Solution {
+public:
+    bool wordBreak(string s, vector<string>& wordDict) {
+        unordered_set<string> words;
+        for (auto word : wordDict) {
+            words.insert(word);
+        }
+        int n = s.size();
+        vector<bool> dp(n + 1, false);
+        dp[0] = true;
+        for (int i = 1; i <= n; ++i) {
+            for (int j = 0; j < i; ++j) {
+                if (dp[j] && words.find(s.substr(j, i - j)) != words.end()) {
+                    dp[i] = true;
+                    break;
+                }
+            }
+        }
+        return dp[n];
+    }
+};
+```
+
+### **Go**
+
+```go
+func wordBreak(s string, wordDict []string) bool {
+	words := make(map[string]bool)
+	for _, word := range wordDict {
+		words[word] = true
+	}
+	n := len(s)
+	dp := make([]bool, n+1)
+	dp[0] = true
+	for i := 1; i <= n; i++ {
+		for j := 0; j < i; j++ {
+			if dp[j] && words[s[j:i]] {
+				dp[i] = true
+				break
+			}
+		}
+	}
+	return dp[n]
+}
+```
 
+### **C#**
+
+```cs
+public class Solution {
+    public bool WordBreak(string s, IList<string> wordDict) {
+        var words = new HashSet<string>(wordDict);
+        int n = s.Length;
+        var dp = new bool[n + 1];
+        dp[0] = true;
+        for (int i = 1; i <= n; ++i)
+        {
+            for (int j = 0; j < i; ++j)
+            {
+                if (dp[j] && words.Contains(s.Substring(j, i - j)))
+                {
+                    dp[i] = true;
+                    break;
+                }
+            }
+        }
+        return dp[n];
+    }
+}
 ```
 
 ### **...**
diff --git a/solution/0100-0199/0139.Word Break/README_EN.md b/solution/0100-0199/0139.Word Break/README_EN.md
@@ -47,18 +47,121 @@ Note that you are allowed to reuse a dictionary word.
 
 ## Solutions
 
+Dynamic Programming.
+
 <!-- tabs:start -->
 
 ### **Python3**
 
 ```python
-
+class Solution:
+    def wordBreak(self, s: str, wordDict: List[str]) -> bool:
+        words = set(wordDict)
+        n = len(s)
+        dp = [False] * (n + 1)
+        dp[0] = True
+        for i in range(1, n + 1):
+            for j in range(i):
+                if dp[j] and s[j:i] in words:
+                    dp[i] = True
+                    break
+        return dp[n]
 ```
 
 ### **Java**
 
 ```java
+class Solution {
+    public boolean wordBreak(String s, List<String> wordDict) {
+        Set<String> words = new HashSet<>(wordDict);
+        int n = s.length();
+        boolean[] dp = new boolean[n + 1];
+        dp[0] = true;
+        for (int i = 1; i <= n; ++i) {
+            for (int j = 0; j < i; ++j) {
+                if (dp[j] && words.contains(s.substring(j, i))) {
+                    dp[i] = true;
+                    break;
+                }
+            }
+        }
+        return dp[n];
+    }
+}
+```
+
+### **C++**
+
+```cpp
+class Solution {
+public:
+    bool wordBreak(string s, vector<string>& wordDict) {
+        unordered_set<string> words;
+        for (auto word : wordDict) {
+            words.insert(word);
+        }
+        int n = s.size();
+        vector<bool> dp(n + 1, false);
+        dp[0] = true;
+        for (int i = 1; i <= n; ++i) {
+            for (int j = 0; j < i; ++j) {
+                if (dp[j] && words.find(s.substr(j, i - j)) != words.end()) {
+                    dp[i] = true;
+                    break;
+                }
+            }
+        }
+        return dp[n];
+    }
+};
+```
+
+### **Go**
+
+```go
+func wordBreak(s string, wordDict []string) bool {
+	words := make(map[string]bool)
+	for _, word := range wordDict {
+		words[word] = true
+	}
+	n := len(s)
+	dp := make([]bool, n+1)
+	dp[0] = true
+	for i := 1; i <= n; i++ {
+		for j := 0; j < i; j++ {
+			if dp[j] && words[s[j:i]] {
+				dp[i] = true
+				break
+			}
+		}
+	}
+	return dp[n]
+}
+```
 
+### **C#**
+
+```cs
+public class Solution {
+    public bool WordBreak(string s, IList<string> wordDict) {
+        var words = new HashSet<string>(wordDict);
+        int n = s.Length;
+        var dp = new bool[n + 1];
+        dp[0] = true;
+        for (int i = 1; i <= n; ++i)
+        {
+            for (int j = 0; j < i; ++j)
+            {
+                if (dp[j] && words.Contains(s.Substring(j, i - j)))
+                {
+                    dp[i] = true;
+                    break;
+                }
+            }
+        }
+        return dp[n];
+    }
+}
 ```
 
 ### **...**
diff --git a/solution/0100-0199/0139.Word Break/Solution.cpp b/solution/0100-0199/0139.Word Break/Solution.cpp
@@ -0,0 +1,21 @@
+class Solution {
+public:
+    bool wordBreak(string s, vector<string>& wordDict) {
+        unordered_set<string> words;
+        for (auto word : wordDict) {
+            words.insert(word);
+        }
+        int n = s.size();
+        vector<bool> dp(n + 1, false);
+        dp[0] = true;
+        for (int i = 1; i <= n; ++i) {
+            for (int j = 0; j < i; ++j) {
+                if (dp[j] && words.find(s.substr(j, i - j)) != words.end()) {
+                    dp[i] = true;
+                    break;
+                }
+            }
+        }
+        return dp[n];
+    }
+};
diff --git a/solution/0100-0199/0139.Word Break/Solution.cs b/solution/0100-0199/0139.Word Break/Solution.cs
@@ -1,29 +1,17 @@
-using System.Collections.Generic;
-using System.Linq;
-
 public class Solution {
     public bool WordBreak(string s, IList<string> wordDict) {
-        var f = new bool[s.Length + 1];
-        f[0] = true;
-        var wordDictGroup = wordDict.GroupBy(word => word.Length);
-        for (var i = 1; i <= s.Length; ++i)
-        {
-            foreach (var wordGroup in wordDictGroup)
-            {
-                var wordLength = wordGroup.Key;
-                if (i >= wordLength && f[i - wordLength])
-                {
-                    foreach (var word in wordGroup)
-                    {
-                        if (s.Substring(i - wordLength, wordLength) == word)
-                        {
-                            f[i] = true;
-                            break;
-                        }
-                    }
+        var words = new HashSet<string>(wordDict);
+        int n = s.Length;
+        var dp = new bool[n + 1];
+        dp[0] = true;
+        for (int i = 1; i <= n; ++i) {
+            for (int j = 0; j < i; ++j) {
+                if (dp[j] && words.Contains(s.Substring(j, i))) {
+                    dp[i] = true;
+                    break;
                 }
             }
         }
-        return f[s.Length];
+        return dp[n];
     }
 }
diff --git a/solution/0100-0199/0139.Word Break/Solution.go b/solution/0100-0199/0139.Word Break/Solution.go
@@ -0,0 +1,18 @@
+func wordBreak(s string, wordDict []string) bool {
+	words := make(map[string]bool)
+	for _, word := range wordDict {
+		words[word] = true
+	}
+	n := len(s)
+	dp := make([]bool, n+1)
+	dp[0] = true
+	for i := 1; i <= n; i++ {
+		for j := 0; j < i; j++ {
+			if dp[j] && words[s[j:i]] {
+				dp[i] = true
+				break
+			}
+		}
+	}
+	return dp[n]
+}
diff --git a/solution/0100-0199/0139.Word Break/Solution.java b/solution/0100-0199/0139.Word Break/Solution.java
@@ -1,21 +1,20 @@
-class Solution {
-    public boolean wordBreak(String s, List<String> wordDict) {
-        if (s == null || s.length() == 0) {
-            return false;
-        }
-        Set<String> words = new HashSet<>(wordDict);
-        boolean[] dp = new boolean[s.length() + 1];
+public class Solution {
+    public bool WordBreak(string s, IList<string> wordDict) {
+        var words = new HashSet<string>(wordDict);
+        int n = s.Length;
+        var dp = new bool[n + 1];
         dp[0] = true;
-
-        for (int i = 1; i <= s.length(); i++) {
-            for (int j = i - 1; j > -1; j--) {
-                dp[i] = dp[j] && words.contains(s.substring(j, i));
-                if (dp[i]) {
+        for (int i = 1; i <= n; ++i)
+        {
+            for (int j = 0; j < i; ++j)
+            {
+                if (dp[j] && words.Contains(s.Substring(j, i - j)))
+                {
+                    dp[i] = true;
                     break;
                 }
             }
         }
-
-        return dp[s.length()];
+        return dp[n];
     }
 }
diff --git a/solution/0100-0199/0139.Word Break/Solution.py b/solution/0100-0199/0139.Word Break/Solution.py
