一刷2800

Author: diguage

README.adoc

@@ -19626,12 +19626,12 @@ TIP: **公众号的微信号是: `jikerizhi`**。__因为众所周知的原因
 //|Medium
 //|
 
-//|{counter:codes}
-//|{leetcode_base_url}/shortest-string-that-contains-three-strings/[2800. Shortest String That Contains Three Strings^]
-//|{source_base_url}/_2800_ShortestStringThatContainsThreeStrings.java[Java]
-//|{doc_base_url}/2800-shortest-string-that-contains-three-strings.adoc[题解]
-//|Medium
-//|
+|{counter:codes}
+|{leetcode_base_url}/shortest-string-that-contains-three-strings/[2800. Shortest String That Contains Three Strings^]
+|{source_base_url}/_2800_ShortestStringThatContainsThreeStrings.java[Java]
+|{doc_base_url}/2800-shortest-string-that-contains-three-strings.adoc[题解]
+|Medium
+|
 
 //|{counter:codes}
 //|{leetcode_base_url}/count-stepping-numbers-in-range/[2801. Count Stepping Numbers in Range^]

docs/2800-shortest-string-that-contains-three-strings.adoc

@@ -1,51 +1,48 @@
 [#2800-shortest-string-that-contains-three-strings]
-= 2800. Shortest String That Contains Three Strings
+= 2800. 包含三个字符串的最短字符串
 
-{leetcode}/problems/shortest-string-that-contains-three-strings/[LeetCode - 2800. Shortest String That Contains Three Strings ^]
+https://leetcode.cn/problems/shortest-string-that-contains-three-strings/[LeetCode - 2800. 包含三个字符串的最短字符串 ^]
 
-Given three strings `a`, `b`, and `c`, your task is to find a string that has the* minimum* length and contains all three strings as *substrings*.
-If there are multiple such strings, return the_ _*lexicographically_ _smallest *one.
+给你三个字符串 `a` ，`b` 和 `c`，你的任务是找到长度 *最短* 的字符串，且这三个字符串都是它的 *子字符串* 。
 
-Return _a string denoting the answer to the problem._
+如果有多个这样的字符串，请你返回 *字典序最小* 的一个。
 
-*Notes*
+请你返回满足题目要求的字符串。
 
+*注意：*
 
-* A string `a` is *lexicographically smaller* than a string `b` (of the same length) if in the first position where `a` and `b` differ, string `a` has a letter that appears *earlier *in the alphabet than the corresponding letter in `b`.
-* A *substring* is a contiguous sequence of characters within a string.
+* 两个长度相同的字符串 `a` 和 `b` ，如果在第一个不相同的字符处，`a` 的字母在字母表中比 `b` 的字母 *靠前* ，那么字符串 `a` 比字符串 `b` *字典序小* 。
+* *子字符串* 是一个字符串中一段连续的字符序列。
 
+*示例 1：*
 
- 
-*Example 1:*
+....
+输入：a = "abc", b = "bca", c = "aaa"
+输出："aaabca"
+解释：字符串 "aaabca" 包含所有三个字符串：a = ans[2...4] ，b = ans[3..5] ，c = ans[0..2] 。结果字符串的长度至少为 6 ，且"aaabca" 是字典序最小的一个。
+....
 
-[subs="verbatim,quotes"]
-----
-*Input:* a = "abc", b = "bca", c = "aaa"
-*Output:* "aaabca"
-*Explanation:*  We show that "aaabca" contains all the given strings: a = ans[2...4], b = ans[3..5], c = ans[0..2]. It can be shown that the length of the resulting string would be at least 6 and "aaabca" is the lexicographically smallest one.
-----
+*示例 2：*
 
-*Example 2:*
+....
+输入：a = "ab", b = "ba", c = "aba"
+输出："aba"
+解释：字符串 "aba" 包含所有三个字符串：a = ans[0..1] ，b = ans[1..2] ，c = ans[0..2] 。由于 c 的长度为 3 ，结果字符串的长度至少为 3 。"aba" 是字典序最小的一个。
+....
 
-[subs="verbatim,quotes"]
-----
-*Input:* a = "ab", b = "ba", c = "aba"
-*Output:* "aba"
-*Explanation: *We show that the string "aba" contains all the given strings: a = ans[0..1], b = ans[1..2], c = ans[0..2]. Since the length of c is 3, the length of the resulting string would be at least 3. It can be shown that "aba" is the lexicographically smallest one.
-
-----
+*提示：*
 
- 
-*Constraints:*
+* `+1 <= a.length, b.length, c.length <= 100+`
+* `a` ，`b` ，`c` 只包含小写英文字母。
 
 
-* `1 <= a.length, b.length, c.length <= 100`
-* `a`, `b`, `c` consist only of lowercase English letters.
-
+== 思路分析
 
+先使用回溯获取三个字符串的所有全排列，然后在这些全排列中，通过合并字符串首尾相同的部分来获取更短的子串，在这些子串中选择最短，字典排序最小的字符串。
 
+NOTE: 合并字符串时，注意处理首尾的相同子串。
 
-== 思路分析
+最初思路是直接合并三个字符，这样会因为没有处理“首尾相同”的子串而让结果变长。
 
 
 [[src-2800]]
@@ -73,4 +70,4 @@ include::{sourcedir}/_2800_ShortestStringThatContainsThreeStrings.java[tag=answe
 
 == 参考资料
 
-
+. https://leetcode.cn/problems/shortest-string-that-contains-three-strings/solutions/2364733/mei-ju-by-endlesscheng-qc44/[2800. 包含三个字符串的最短字符串 - 枚举^]

docs/index.adoc

@@ -5684,7 +5684,7 @@ include::2684-maximum-number-of-moves-in-a-grid.adoc[leveloffset=+1]
 
 // include::2799-count-complete-subarrays-in-an-array.adoc[leveloffset=+1]
 
-// include::2800-shortest-string-that-contains-three-strings.adoc[leveloffset=+1]
+include::2800-shortest-string-that-contains-three-strings.adoc[leveloffset=+1]
 
 // include::2801-count-stepping-numbers-in-range.adoc[leveloffset=+1]
 

logbook/202503.adoc

@@ -648,6 +648,11 @@ endif::[]
 |{doc_base_url}/0705-design-hashset.adoc[题解]
 |✅ 使用开放地址法解决哈希冲突。
 
+|{counter:codes2503}
+|{leetcode_base_url}/shortest-string-that-contains-three-strings/[2800. 包含三个字符串的最短字符串^]
+|{doc_base_url}/2800-shortest-string-that-contains-three-strings.adoc[题解]
+|❌ 先求三个字符串的全排列，然后合并（合并时注意处理首尾相同子串，减少合并字符串的长度），在这些合并后的字符串中选择最短，字典排序最小的字符串。
+
 |===
 
 截止目前，本轮练习一共完成 {codes2503} 道题。

src/main/java/com/diguage/algo/leetcode/_2800_ShortestStringThatContainsThreeStrings.java

@@ -0,0 +1,67 @@
+package com.diguage.algo.leetcode;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+public class _2800_ShortestStringThatContainsThreeStrings {
+  // tag::answer[]
+
+  /**
+   * @author D瓜哥 · https://www.diguage.com
+   * @since 2025-05-05 22:38:45
+   */
+  public String minimumString(String a, String b, String c) {
+    List<List<String>> perms = new ArrayList<>(6);
+    List<String> ss = Arrays.asList(a, b, c);
+    backtrack(ss, perms, new ArrayList<>(), new boolean[ss.size()]);
+    String result = null;
+    for (List<String> perm : perms) {
+      String temp = merge(merge(perm.get(0), perm.get(1)), perm.get(2));
+      if (result == null || temp.length() < result.length()
+        || temp.length() == result.length() && temp.compareTo(result) < 0) {
+        result = temp;
+      }
+    }
+    return result;
+  }
+
+  private String merge(String a, String b) {
+    if (a.contains(b)) return a;
+    if (b.contains(a)) return b;
+    int min = Math.min(a.length(), b.length());
+    for (int i = min; i > 0; i--) {
+      // 如果 a 的结尾和 b 的开头子串相同，则该子串只需要出现一次
+      if (a.substring(a.length() - i)
+        .equals(b.substring(0, i))) {
+        return a + b.substring(i);
+      }
+    }
+    return a + b;
+  }
+
+  private void backtrack(List<String> ss, List<List<String>> set,
+                         List<String> path, boolean[] used) {
+    if (ss.size() == path.size()) {
+      set.add(new ArrayList<>(path));
+      return;
+    }
+    for (int i = 0; i < ss.size(); i++) {
+      if (used[i]) {
+        continue;
+      }
+      used[i] = true;
+      path.add(ss.get(i));
+      backtrack(ss, set, path, used);
+      path.removeLast();
+      used[i] = false;
+    }
+  }
+
+  // end::answer[]
+  public static void main(String[] args) {
+    new _2800_ShortestStringThatContainsThreeStrings()
+//      .merge("abc", "def");
+      .minimumString("abc", "bca", "aaa");
+  }
+}