二刷139

Author: diguage

docs/0139-word-break.adoc

@@ -1,51 +1,97 @@
 [#0139-word-break]
-= 139. Word Break
+= 139. 单词拆分
 
-{leetcode}/problems/word-break/[LeetCode - Word Break^]
+https://leetcode.cn/problems/word-break/[LeetCode - 139. 单词拆分 ^]
 
-TODO: 似乎明白了，又似乎不明白。
+给你一个字符串 `s` 和一个字符串列表 `wordDict` 作为字典。如果可以利用字典中出现的一个或多个单词拼接出 `s` 则返回 `true`。
 
-Given a *non-empty* string _s_ and a dictionary _wordDict_ containing a list of *non-empty* words, determine if _s_ can be segmented into a space-separated sequence of one or more dictionary words.
+**注意：**不要求字典中出现的单词全部都使用，并且字典中的单词可以重复使用。
 
-*Note:*
+*示例 1：*
 
+....
+输入: s = "leetcode", wordDict = ["leet", "code"]
+输出: true
+解释: 返回 true 因为 "leetcode" 可以由 "leet" 和 "code" 拼接成。
+....
 
-* The same word in the dictionary may be reused multiple times in the segmentation.
-* You may assume the dictionary does not contain duplicate words.
+*示例 2：*
 
+....
+输入: s = "applepenapple", wordDict = ["apple", "pen"]
+输出: true
+解释: 返回 true 因为 "applepenapple" 可以由 "apple" "pen" "apple" 拼接成。
+     注意，你可以重复使用字典中的单词。
+....
 
-*Example 1:*
+*示例 3：*
 
-[subs="verbatim,quotes,macros"]
-----
-*Input:* s = "leetcode", wordDict = ["leet", "code"]
-*Output:* true
-*Explanation:* Return true because `"leetcode"` can be segmented as `"leet code"`.
-----
+....
+输入: s = "catsandog", wordDict = ["cats", "dog", "sand", "and", "cat"]
+输出: false
+....
 
-*Example 2:*
+*提示：*
 
-[subs="verbatim,quotes,macros"]
-----
-*Input:* s = "applepenapple", wordDict = ["apple", "pen"]
-*Output:* true
-*Explanation:* Return true because `"`applepenapple`"` can be segmented as `"`apple pen apple`"`.
-             Note that you are allowed to reuse a dictionary word.
-----
+* `+1 <= s.length <= 300+`
+* `+1 <= wordDict.length <= 1000+`
+* `+1 <= wordDict[i].length <= 20+`
+* `s` 和 `wordDict[i]` 仅由小写英文字母组成
+* `wordDict` 中的所有字符串 *互不相同*
 
-*Example 3:*
 
-[subs="verbatim,quotes,macros"]
-----
-*Input:* s = "catsandog", wordDict = ["cats", "dog", "sand", "and", "cat"]
-*Output:* false
-----
+== 思路分析
+
+回溯+备忘录：
+
+image::images/0139-01.png[{image_attr}]
+
+动态规划
+
+image::images/0139-02.png[{image_attr}]
+
+image::images/0139-03.png[{image_attr}]
 
+image::images/0139-04.png[{image_attr}]
 
+我的思路：
+
+stem:[dp\[i+j\] = dp\[i\] & s\[i, i+j\] in dict]
+
+从 stem:[0] 到 stem:[i] 已经确定。从当前位置 stem:[i] 向前推进到 stem:[i+j]，其中 stem:[j] 是某个一个单词的长度。
 
 [[src-0139]]
+[tabs]
+====
+一刷::
++
+--
 [{java_src_attr}]
 ----
 include::{sourcedir}/_0139_WordBreak.java[tag=answer]
 ----
+--
+
+二刷（回溯+备忘录）::
++
+--
+[{java_src_attr}]
+----
+include::{sourcedir}/_0139_WordBreak_20.java[tag=answer]
+----
+--
+
+二刷（动态规划）::
++
+--
+[{java_src_attr}]
+----
+include::{sourcedir}/_0139_WordBreak_21.java[tag=answer]
+----
+--
+====
+
+== 参考资料
 
+. https://leetcode.cn/problems/word-break/solutions/302779/shou-hui-tu-jie-san-chong-fang-fa-dfs-bfs-dong-tai/[139. 单词拆分 - 「手画图解」剖析三种解法: DFS, BFS, 动态规划^] -- 这个题解非常好，从回溯，到加备忘录
+. https://leetcode.cn/problems/word-break/solutions/50986/dong-tai-gui-hua-ji-yi-hua-hui-su-zhu-xing-jie-shi/[139. 单词拆分 - 动态规划+记忆化回溯 逐行解释 Python3^]

docs/images/0139-01.png

@@ -6,7 +6,7 @@ endif::[]
 :doc_base_url: link:../docs
 
 
-[cols="7,32,7,54",options="header"]
+[cols="7,30,7,56",options="header"]
 |===
 |序号 |题目 |题解 |备注
 
@@ -340,6 +340,10 @@ endif::[]
 |{doc_base_url}/0221-maximal-square.adoc[题解]
 |✅ 动态规划。直接将结果存储在参数矩阵上。如果正方形想扩大，则左边，左上和上面三个都是正方形时才可以，可以直接去这三者中的最小值。
 
+|{counter:codes2503}
+|{leetcode_base_url}/word-break/[139. 单词拆分^]
+|{doc_base_url}/0139-word-break.adoc[题解]
+|⭕️ 回溯+备忘录。首先想到的是回溯，但是超时（通过34/47的测试用例）。参考别人题解后，得到启发，加上备忘录通过。参考答案写出了动态规划的解法。*思考如何从基于回溯+备忘录转变为动态规划？*
 
 |===
 

docs/images/0139-02.png

@@ -52,6 +52,9 @@ public class _0139_WordBreak {
      * Memory Usage: 44.3 MB, less than 5.08% of Java online submissions for Word Break.
      *
      * Copy from: https://leetcode-cn.com/problems/word-break/solution/dan-ci-chai-fen-by-leetcode/[单词拆分 - 单词拆分 - 力扣（LeetCode）]
+     *
+     * @author D瓜哥 · https://www.diguage.com
+     * @since 2020-01-24 09:39
      */
     public boolean wordBreak(String s, List<String> wordDict) {
         boolean[] dp = new boolean[s.length() + 1];

docs/images/0139-03.png

@@ -0,0 +1,65 @@
+package com.diguage.algo.leetcode;
+
+import java.util.Comparator;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+
+public class _0139_WordBreak_20 {
+  // tag::answer[]
+  /**
+   * 纯回溯通过 34/47 的测试用例。在 35 个测试用例时超时。
+   *
+   * 加备忘录则可以通过。效率还挺高，时间和内存都超过了 80%+ 的用户
+   *
+   * @author D瓜哥 · https://www.diguage.com
+   * @since 2025-04-19 15:41:59
+   */
+  public boolean wordBreak(String s, List<String> wordDict) {
+    Set<Integer> wordLengths = new HashSet<>();
+    for (String string : wordDict) {
+      wordLengths.add(string.length());
+    }
+    Set<String> set = new HashSet<>(wordDict);
+    List<Integer> lengths = wordLengths.stream()
+      .sorted(Comparator.reverseOrder()).toList();
+    // 备忘录：记录剩余 i 个字符时，字符串是否可以拆分
+    Boolean[] memo = new Boolean[s.length()];
+    return backtrack(s, set, lengths, memo);
+  }
+
+  private boolean backtrack(String s, Set<String> set,
+                            List<Integer> lengths, Boolean[] memo) {
+    if (s == null || s.isEmpty() || set.contains(s)) {
+      return true;
+    }
+    if (s.length() < lengths.getLast()) {
+      return false;
+    }
+    for (Integer i : lengths) {
+      if (s.length() < i) {
+        continue;
+      }
+      String prefix = s.substring(0, i);
+      if (!set.contains(prefix)) {
+        continue;
+      }
+      String substring = s.substring(i);
+      if (memo[substring.length() - 1] != null) {
+        return memo[substring.length() - 1];
+      }
+      boolean track = backtrack(substring, set, lengths, memo);
+      memo[substring.length() - 1] = track;
+      if (track) {
+        return true;
+      }
+    }
+    return false;
+  }
+  // end::answer[]
+
+  public static void main(String[] args) {
+    new _0139_WordBreak_20().wordBreak("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaab",
+      List.of("a", "aa", "aaa", "aaaa", "aaaaa", "aaaaaa", "aaaaaaa", "aaaaaaaa", "aaaaaaaaa", "aaaaaaaaaa"));
+  }
+}

docs/images/0139-04.png

@@ -0,0 +1,42 @@
+package com.diguage.algo.leetcode;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class _0139_WordBreak_21 {
+  // tag::answer[]
+  /**
+   * @author D瓜哥 · https://www.diguage.com
+   * @since 2025-04-19 17:13:31
+   */
+  public boolean wordBreak(String s, List<String> wordDict) {
+    boolean[] dp = new boolean[s.length() + 1];
+    dp[0] = true;
+    for (int i = 0; i < s.length(); i++) {
+      // 如果前 i 个字符不能被拆分，则跳过该情况
+      if (!dp[i]) {
+        continue;
+      }
+      for (String word : wordDict) {
+        int wordLen = word.length();
+        if (s.length() < i + wordLen) {
+          continue;
+        }
+        // 如果已经确认可以拆分，则跳过
+        if (dp[i + wordLen]) {
+          continue;
+        }
+        String substring = s.substring(i, i + wordLen);
+        // dp[i+length] = dp[i] && s[i, i+length]∈dict
+        dp[i + wordLen] = dp[i] && word.equals(substring);
+      }
+    }
+    return dp[s.length()];
+  }
+  // end::answer[]
+
+  public static void main(String[] args) {
+    new _0139_WordBreak_21().wordBreak("aaaaaaa",
+      new ArrayList<>(List.of("aaaa", "aaa")));
+  }
+}