一刷721

diguage · diguage · commit b1bfdef304e5 · 2025-04-22T00:53:38.000+08:00
diff --git a/README.adoc b/README.adoc
@@ -5072,14 +5072,14 @@ TIP: **公众号的微信号是: `jikerizhi`**。__因为众所周知的原因
 //|{doc_base_url}/0720-longest-word-in-dictionary.adoc[题解]
 //|Easy
 //|
-//
-//|{counter:codes}
-//|{leetcode_base_url}/accounts-merge/[721. Accounts Merge^]
-//|{source_base_url}/_0721_AccountsMerge.java[Java]
-//|{doc_base_url}/0721-accounts-merge.adoc[题解]
-//|Medium
-//|
-//
+
+|{counter:codes}
+|{leetcode_base_url}/accounts-merge/[721. Accounts Merge^]
+|{source_base_url}/_0721_AccountsMerge.java[Java]
+|{doc_base_url}/0721-accounts-merge.adoc[题解]
+|Medium
+|
+
 //|{counter:codes}
 //|{leetcode_base_url}/remove-comments/[722. Remove Comments^]
 //|{source_base_url}/_0722_RemoveComments.java[Java]
diff --git a/docs/0000-18-union-find-set.adoc b/docs/0000-18-union-find-set.adoc
@@ -15,6 +15,8 @@ image::images/union-find-2.png[title="并查集合并",alt="并查集合并",{im
 
 image::images/union-find-3.png[title="并查集再合并",alt="并查集再合并",{image_attr}]
 
+TIP: 在合并时，是修改根节点的指针 `parent[ap] = bp`，而不是修改节点的指针 `parent[a] = bp`。
+
 并查集除了 `union`，还有一个重要操作是 `connnected(a, b)`。判断方法也很简单，从节点 `a` 和 `b` 开始，向上查找，直到两个节点的根节点，判断两个根节点是否相等即可判断两个节点是否已经连接。为了加快这个判断速度，可以对其进行“路径压缩”，直白点说，就是将所有树的节点，都直接指向根节点，这样只需要一步即可到达根节点。路径压缩如图所示：
 
 image::images/union-find-4.png[title="并查集路径压缩",alt="并查集路径压缩",{image_attr}]
diff --git a/docs/0000-21-decrease-and-conquer.adoc b/docs/0000-21-decrease-and-conquer.adoc
@@ -14,6 +14,10 @@ D瓜哥最早知道减治法是在 https://book.douban.com/subject/26337727/[《
 * **减去的规模是可变的。**在减治法的减可变规模(variable-size-decrease)变化形式中，算法在每次迭代时，规模减小的模式都是不同的。
 ** 计算最大公约数的欧几里得算法是这种情况的一个很好的例子。 stem:[gcd(m, n)=gcd(n,m mod n)]
 
+== 经典题目
+
+. xref:0721-accounts-merge.adoc[721. Accounts Merge] -- https://leetcode.cn/problems/accounts-merge/solutions/2844329/qu-qiao-de-fang-fa-3miao-kan-dong-si-wei-llcx/[721. 账户合并 - 取巧的减治方法，3秒看懂^]
+
 == 参考资料
 
 . https://cloud.tencent.com/developer/article/1532598[【算法学习】减治 · 分治 · 变治^]
diff --git a/docs/0721-accounts-merge.adoc b/docs/0721-accounts-merge.adoc
@@ -1,39 +1,101 @@
 [#0721-accounts-merge]
-= 721. Accounts Merge
+= 721. 账户合并
 
-{leetcode}/problems/accounts-merge/[LeetCode - Accounts Merge^]
+https://leetcode.cn/problems/accounts-merge/[LeetCode - 721. 账户合并 ^]
 
-Given a list `accounts`, each element `accounts[i]` is a list of strings, where the first element `accounts[i][0]` is a _name_, and the rest of the elements are _emails_ representing emails of the account.
+给定一个列表 `accounts`，每个元素 `accounts[i]` 是一个字符串列表，其中第一个元素 `accounts[i][0]` 是 _名称 (name)_，其余元素是 *_emails_* 表示该账户的邮箱地址。
 
-Now, we would like to merge these accounts.  Two accounts definitely belong to the same person if there is some email that is common to both accounts.  Note that even if two accounts have the same name, they may belong to different people as people could have the same name.  A person can have any number of accounts initially, but all of their accounts definitely have the same name.
+现在，我们想合并这些账户。如果两个账户都有一些共同的邮箱地址，则两个账户必定属于同一个人。请注意，即使两个账户具有相同的名称，它们也可能属于不同的人，因为人们可能具有相同的名称。一个人最初可以拥有任意数量的账户，但其所有账户都具有相同的名称。
 
-After merging the accounts, return the accounts in the following format: the first element of each account is the name, and the rest of the elements are emails *in sorted order*.  The accounts themselves can be returned in any order.
+合并账户后，按以下格式返回账户：每个账户的第一个元素是名称，其余元素是 *按字符 ASCII 顺序排列* 的邮箱地址。账户本身可以以 *任意顺序* 返回。
 
-*Example 1:*
+*示例 1：*
 
-[subs="verbatim,quotes,macros"]
-----
-*Input:* 
-accounts = [["John", "johnsmith@mail.com", "john00@mail.com"], ["John", "johnnybravo@mail.com"], ["John", "johnsmith@mail.com", "john_newyork@mail.com"], ["Mary", "mary@mail.com"]]
-*Output:* [["John", 'john00@mail.com', 'john_newyork@mail.com', 'johnsmith@mail.com'],  ["John", "johnnybravo@mail.com"], ["Mary", "mary@mail.com"]]
-*Explanation:* 
-The first and third John's are the same person as they have the common email "johnsmith@mail.com".
-The second John and Mary are different people as none of their email addresses are used by other accounts.
-We could return these lists in any order, for example the answer [['Mary', 'mary@mail.com'], ['John', 'johnnybravo@mail.com'], 
-['John', 'john00@mail.com', 'john_newyork@mail.com', 'johnsmith@mail.com']] would still be accepted.
-----
+....
+输入：accounts = [
+       ["John", "johnsmith@mail.com", "john00@mail.com"],
+       ["John", "johnnybravo@mail.com"],
+       ["John", "johnsmith@mail.com", "john_newyork@mail.com"],
+       ["Mary", "mary@mail.com"]
+     ]
+输出：[
+       ["John", 'john00@mail.com', 'john_newyork@mail.com', 'johnsmith@mail.com'],
+       ["John", "johnnybravo@mail.com"],
+       ["Mary", "mary@mail.com"]
+     ]
+解释：
+第一个和第三个 John 是同一个人，因为他们有共同的邮箱地址 "johnsmith@mail.com"。
+第二个 John 和 Mary 是不同的人，因为他们的邮箱地址没有被其他帐户使用。
+可以以任何顺序返回这些列表，例如答案 [['Mary'，'mary@mail.com']，['John'，'johnnybravo@mail.com']，
+['John'，'john00@mail.com'，'john_newyork@mail.com'，'johnsmith@mail.com']] 也是正确的。
+....
+
+*示例 2：*
+
+....
+输入：accounts = [
+       ["Gabe","Gabe0@m.co","Gabe3@m.co","Gabe1@m.co"],
+       ["Kevin","Kevin3@m.co","Kevin5@m.co","Kevin0@m.co"],
+       ["Ethan","Ethan5@m.co","Ethan4@m.co","Ethan0@m.co"],
+       ["Hanzo","Hanzo3@m.co","Hanzo1@m.co","Hanzo0@m.co"],
+       ["Fern","Fern5@m.co","Fern1@m.co","Fern0@m.co"]
+     ]
+输出：[
+       ["Ethan","Ethan0@m.co","Ethan4@m.co","Ethan5@m.co"],
+       ["Gabe","Gabe0@m.co","Gabe1@m.co","Gabe3@m.co"],
+       ["Hanzo","Hanzo0@m.co","Hanzo1@m.co","Hanzo3@m.co"],
+       ["Kevin","Kevin0@m.co","Kevin3@m.co","Kevin5@m.co"],
+       ["Fern","Fern0@m.co","Fern1@m.co","Fern5@m.co"]
+     ]
+....
+
+*提示：*
+
+* `+1 <= accounts.length <= 1000+`
+* `+2 <= accounts[i].length <= 10+`
+* `+1 <= accounts[i][j].length <= 30+`
+* `accounts[i][0]` 由英文字母组成
+* `accounts[i][j] (for j > 0)` 是有效的邮箱地址
 
 
-*Note:*
-. The length of `accounts` will be in the range `[1, 1000]`.</li>
-. The length of `accounts[i]` will be in the range `[1, 10]`.</li>
-. The length of `accounts[i][j]` will be in the range `[1, 30]`.</li>
+== 思路分析
 
+并查集。
 
+通过邮箱编号建立连接，而不是通过账户索引建立连接。
+
+image::images/0721-10.png[{image_attr}]
+
+也可以使用深度优先遍历。
+
+image::images/0721-11.png[{image_attr}]
 
 [[src-0721]]
+[tabs]
+====
+一刷::
++
+--
 [{java_src_attr}]
 ----
 include::{sourcedir}/_0721_AccountsMerge.java[tag=answer]
 ----
+--
+
+// 二刷::
+// +
+// --
+// [{java_src_attr}]
+// ----
+// include::{sourcedir}/_0721_AccountsMerge_2.java[tag=answer]
+// ----
+// --
+====
+
+
+== 参考资料
 
+. https://leetcode.cn/problems/accounts-merge/solutions/564305/zhang-hu-he-bing-by-leetcode-solution-3dyq/[721. 账户合并 - 官方题解^]
+. https://leetcode.cn/problems/accounts-merge/solutions/2844186/ha-xi-biao-dfspythonjavacgojsrust-by-end-z9nh/[721. 账户合并 - 哈希表 + DFS^]
+. https://leetcode.cn/problems/accounts-merge/solutions/564451/tu-jie-yi-ran-shi-bing-cha-ji-by-yexiso-5ncf/[721. 账户合并 - 【图解】依然是并查集^]
+. https://leetcode.cn/problems/accounts-merge/solutions/2844329/qu-qiao-de-fang-fa-3miao-kan-dong-si-wei-llcx/[721. 账户合并 - 取巧的减治方法，3秒看懂，思维难度小，复杂度就大，图一乐 :)^]
diff --git a/docs/images/0721-10.png b/docs/images/0721-10.png
diff --git a/docs/images/0721-11.png b/docs/images/0721-11.png
diff --git a/docs/index.adoc b/docs/index.adoc
@@ -1524,7 +1524,7 @@ include::0718-maximum-length-of-repeated-subarray.adoc[leveloffset=+1]
 
 // include::0720-longest-word-in-dictionary.adoc[leveloffset=+1]
 
-// include::0721-accounts-merge.adoc[leveloffset=+1]
+include::0721-accounts-merge.adoc[leveloffset=+1]
 
 // include::0722-remove-comments.adoc[leveloffset=+1]
 
diff --git a/logbook/202503.adoc b/logbook/202503.adoc
@@ -418,6 +418,11 @@ endif::[]
 |{doc_base_url}/0131-palindrome-partitioning.adoc[题解]
 |✅ 回溯
 
+|{counter:codes2503}
+|{leetcode_base_url}/accounts-merge/[721. 账户合并^]
+|{doc_base_url}/0721-accounts-merge.adoc[题解]
+|❌ 并查集。通过邮箱编号建立连接，而不是通过账户索引建立连接。
+
 |===
 
 截止目前，本轮练习一共完成 {codes2503} 道题。
diff --git a/src/main/java/com/diguage/algo/leetcode/_0721_AccountsMerge.java b/src/main/java/com/diguage/algo/leetcode/_0721_AccountsMerge.java
@@ -0,0 +1,104 @@
+package com.diguage.algo.leetcode;
+
+import java.util.*;
+
+public class _0721_AccountsMerge {
+  // tag::answer[]
+
+  /**
+   * @author D瓜哥 · https://www.diguage.com
+   * @since 2025-04-21 21:49:58
+   */
+  public List<List<String>> accountsMerge(List<List<String>> accounts) {
+    Map<String, Integer> emailToNoMap = new HashMap<>();
+    Map<String, String> emailToNameMap = new HashMap<>();
+    int emailCount = 0;
+    for (List<String> account : accounts) {
+      String name = account.getFirst();
+      for (int i = 1; i < account.size(); i++) {
+        String email = account.get(i);
+        if (!emailToNoMap.containsKey(email)) {
+          emailToNoMap.put(email, emailCount++);
+          emailToNameMap.put(email, name);
+        }
+      }
+    }
+    UnionFind uf = new UnionFind(emailCount);
+    for (List<String> account : accounts) {
+      String firstEmail = account.get(1);
+      Integer ai = emailToNoMap.get(firstEmail);
+      for (int j = 2; j < account.size(); j++) {
+        Integer bi = emailToNoMap.get(account.get(j));
+        uf.union(ai, bi);
+      }
+    }
+    Map<Integer, List<String>> noToEmailMap = new HashMap<>();
+    emailToNoMap.forEach((email, no) -> {
+      int id = uf.find(no);
+      List<String> emails = noToEmailMap.computeIfAbsent(id, v -> new ArrayList<>());
+      emails.add(email);
+    });
+    List<List<String>> result = new ArrayList<>();
+    for (List<String> emails : noToEmailMap.values()) {
+      List<String> account = new ArrayList<>(emails.size() + 1);
+      account.add(emailToNameMap.get(emails.getFirst()));
+      Collections.sort(emails);
+      account.addAll(emails);
+      result.add(account);
+    }
+    return result;
+  }
+
+  private static class UnionFind {
+    int[] parent;
+
+    public UnionFind(int size) {
+      this.parent = new int[size];
+      for (int i = 0; i < size; i++) {
+        parent[i] = i;
+      }
+    }
+
+    public void union(int a, int b) {
+      int ap = find(a);
+      int bp = find(b);
+      if (ap == bp) {
+        return;
+      }
+      if (ap < bp) {
+        parent[bp] = ap;
+      } else {
+        parent[ap] = bp;
+      }
+    }
+
+    public int find(int a) {
+      int ap = parent[a];
+      List<Integer> path = new ArrayList<>();
+      path.add(a);
+      while (ap != parent[ap]) {
+        path.add(ap);
+        ap = parent[ap];
+      }
+      for (Integer i : path) {
+        parent[i] = ap;
+      }
+      return ap;
+    }
+  }
+  // end::answer[]
+  public static void main(String[] args) {
+    new _0721_AccountsMerge().accountsMerge(new ArrayList<>(List.of(
+      new ArrayList<>(List.of("David", "David0@m.co", "David4@m.co", "David3@m.co")),
+      new ArrayList<>(List.of("David", "David5@m.co", "David5@m.co", "David0@m.co")),
+      new ArrayList<>(List.of("David", "David1@m.co", "David4@m.co", "David0@m.co")),
+      new ArrayList<>(List.of("David", "David0@m.co", "David1@m.co", "David3@m.co")),
+      new ArrayList<>(List.of("David", "David4@m.co", "David1@m.co", "David3@m.co")))));
+//    new _0721_AccountsMerge().accountsMerge(new ArrayList<>(List.of(
+//      new ArrayList<>(List.of("David", "David0@m.co", "David1@m.co")),
+//      new ArrayList<>(List.of("David", "David3@m.co", "David4@m.co")),
+//      new ArrayList<>(List.of("David", "David4@m.co", "David5@m.co")),
+//      new ArrayList<>(List.of("David", "David2@m.co", "David3@m.co")),
+//      new ArrayList<>(List.of("David", "David1@m.co", "David2@m.co")))));
+  }
+}
