一刷547

Author: diguage

Diff for: README.adoc

@@ -3854,14 +3854,14 @@ TIP: **公众号的微信号是: `jikerizhi`**。__因为众所周知的原因
 //|{doc_base_url}/0546-remove-boxes.adoc[题解]
 //|Hard
 //|
-//
-//|{counter:codes}
-//|{leetcode_base_url}/friend-circles/[547. Friend Circles^]
-//|{source_base_url}/_0547_FriendCircles.java[Java]
-//|{doc_base_url}/0547-friend-circles.adoc[题解]
-//|Medium
-//|
-//
+
+|{counter:codes}
+|{leetcode_base_url}/number-of-provinces/[547. 省份数量]
+|{source_base_url}/_0547_NumberOfProvinces.java[Java]
+|{doc_base_url}/0547-number-of-provinces.adoc[题解]
+|Medium
+|
+
 //|{counter:codes}
 //|{leetcode_base_url}/split-array-with-equal-sum/[548. Split Array with Equal Sum^]
 //|{source_base_url}/_0548_SplitArrayWithEqualSum.java[Java]

Diff for: docs/.asciidoctorconfig

@@ -11,6 +11,7 @@
 :diagram_attr: format=svg,align="center",width=95%
 
 :sourcedir: {asciidoctorconfigdir}/../src/main/java/com/diguage/algo/leetcode
+:labdir: {asciidoctorconfigdir}/../src/test/java/com/diguage/labs
 :java_src_attr: source%nowrap,java,indent=0,linenums,subs="attributes,verbatim,quotes"
 
 :doc_base_url: {asciidoctorconfigdir}/../docs

Diff for: docs/0000-18-union-find-set.adoc

@@ -1,5 +1,30 @@
 [#0000-18-union-find-set]
-= Union Find Set 查并集
+= Union Find Set 并查集
+
+并查集算法，英文是 Union-Find，是解决动态连通性（Dynamic Conectivity）问题的一种算法。动态连通性是计算机图论中的一种数据结构，动态维护图结构中相连信息。简单的说就是，图中各个节点之间是否相连、如何将两个节点连接，连接后还剩多少个连通分量。
+
+动态连通性其实可以抽象成给一幅图连线。假设用一个数组表示一堆节点，每个节点都是一个连通分量。初始化视图如下：
+
+image::images/union-find-1.png[title="并查集初始化",alt="并查集初始化",{image_attr}]
+
+并查集的一个重要操作是 `union(a, b)`，就是将节点 `a` 和节点 `b` 建立连接。如图所示：
+
+image::images/union-find-2.png[title="并查集合并",alt="并查集合并",{image_attr}]
+
+`union(a, b)` 还可以将已经建立的两个“子网”进行连接：
+
+image::images/union-find-3.png[title="并查集再合并",alt="并查集再合并",{image_attr}]
+
+并查集除了 `union`，还有一个重要操作是 `connnected(a, b)`。判断方法也很简单，从节点 `a` 和 `b` 开始，向上查找，直到两个节点的根节点，判断两个根节点是否相等即可判断两个节点是否已经连接。为了加快这个判断速度，可以对其进行“路径压缩”，直白点说，就是将所有树的节点，都直接指向根节点，这样只需要一步即可到达根节点。路径压缩如图所示：
+
+image::images/union-find-4.png[title="并查集路径压缩",alt="并查集路径压缩",{image_attr}]
+
+简单代码实现如下：
+
+[{java_src_attr}]
+----
+include::{labdir}/UnionFind.java[]
+----
 
 == 经典题目
 
@@ -94,3 +119,5 @@
 == 参考资料
 
 . https://leetcode.cn/problems/redundant-connection/solutions/372045/yi-wen-zhang-wo-bing-cha-ji-suan-fa-by-a-fei-8/[684. 冗余连接 - 一文掌握并查集算法^]
+. https://blog.csdn.net/qq_57469718/article/details/125416286[并查集(Union-Find) (图文详解)^]
+. https://www.cnblogs.com/gczr/p/12077934.html[Union-Find 并查集算法^]

Diff for: docs/0547-friend-circles.adoc

@@ -0,0 +1,71 @@
+[#0547-number-of-provinces]
+= 547. 省份数量
+
+https://leetcode.cn/problems/number-of-provinces/[LeetCode - 547. 省份数量 ^]
+
+有 `n` 个城市，其中一些彼此相连，另一些没有相连。如果城市 `a` 与城市 `b` 直接相连，且城市 `b` 与城市 `c` 直接相连，那么城市 `a` 与城市 `c` 间接相连。
+
+*省份* 是一组直接或间接相连的城市，组内不含其他没有相连的城市。
+
+给你一个 `n x n` 的矩阵 `isConnected` ，其中 `isConnected[i][j] = 1` 表示第 `i` 个城市和第 `j` 个城市直接相连，而 `isConnected[i][j] = 0` 表示二者不直接相连。
+
+返回矩阵中 *省份* 的数量。
+
+*示例 1：*
+
+image:images/0547-01.jpg[{image_attr}]
+
+....
+输入：isConnected = [[1,1,0],[1,1,0],[0,0,1]]
+输出：2
+....
+
+*示例 2：*
+
+image:images/0547-02.jpg[{image_attr}]
+
+....
+输入：isConnected = [[1,0,0],[0,1,0],[0,0,1]]
+输出：3
+....
+
+*提示：*
+
+* `+1 <= n <= 200+`
+* `n == isConnected.length`
+* `n == isConnected[i].length`
+* `isConnected[i][j]` 为 `1` 或 `0`
+* `isConnected[i][i] == 1`
+* `isConnected[i][j] == isConnected[j][i]`
+
+
+== 思路分析
+
+这就是一道典型的并查集题目，所谓的“返回省份数量”就是求解连通分量。这道题的连通性是通过一个矩阵表示的，所以，首先需要将这个矩阵转换成一个 xref:0000-18-union-find-set.adoc[Union Find Set 并查集] 中讲解的数组。由于 `(i, j)` 和 `(j, i)` 表示的含义一样，所以只需要扫描矩阵的右上部分或者左下部分即可。代码如下：
+
+[[src-0547]]
+[tabs]
+====
+一刷::
++
+--
+[{java_src_attr}]
+----
+include::{sourcedir}/_0547_NumberOfProvinces.java[tag=answer]
+----
+--
+
+// 二刷::
+// +
+// --
+// [{java_src_attr}]
+// ----
+// include::{sourcedir}/_0547_NumberOfProvinces_2.java[tag=answer]
+// ----
+// --
+====
+
+
+== 参考资料
+
+

Diff for: docs/0547-number-of-provinces.adoc

@@ -1170,7 +1170,7 @@ include::0543-diameter-of-binary-tree.adoc[leveloffset=+1]
 
 // include::0546-remove-boxes.adoc[leveloffset=+1]
 
-// include::0547-friend-circles.adoc[leveloffset=+1]
+include::0547-number-of-provinces.adoc[leveloffset=+1]
 
 // include::0548-split-array-with-equal-sum.adoc[leveloffset=+1]
 

Diff for: docs/images/0547-01.jpg

@@ -123,12 +123,17 @@ endif::[]
 |{counter:codes2503}
 |{leetcode_base_url}/reverse-nodes-in-k-group/[25. K 个一组翻转链表^]
 |{doc_base_url}/0025-reverse-nodes-in-k-group.adoc[题解]
-|✅ 分段递归反转，在拼接
+|✅ 分段递归反转，再拼接
 
 |{counter:codes2503}
 |{leetcode_base_url}/implement-trie-prefix-tree/[208. 实现 Trie (前缀树)^]
 |{doc_base_url}/0208-implement-trie-prefix-tree.adoc[题解]
-|✅ 竟然一次通过
+|✅ 前缀树，竟然一次通过
+
+|{counter:codes2503}
+|{leetcode_base_url}/number-of-provinces/[547. 省份数量]
+|{doc_base_url}/0547-number-of-provinces.adoc[题解]
+|✅ 并查集，竟然一次通过
 
 |===
 

Diff for: docs/images/0547-02.jpg

@@ -435,6 +435,7 @@
           <sourceDocumentName>index.adoc</sourceDocumentName>
           <attributes>
             <sourcedir>${project.build.sourceDirectory}/com/diguage/algo/leetcode</sourcedir>
+            <labdir>${project.build.testSourceDirectory}/com/diguage/labs</labdir>
             <basedir>${project.basedir}</basedir>
             <doctype>book</doctype>
             <stem>latexmath</stem>

Diff for: docs/images/union-find-1.png

@@ -0,0 +1,91 @@
+package com.diguage.algo.leetcode;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class _0547_NumberOfProvinces {
+  // tag::answer[]
+
+/**
+ * @author D瓜哥 · https://www.diguage.com
+ * @since 2025-04-03 22:15:52
+ */
+public int findCircleNum(int[][] isConnected) {
+  int len = isConnected.length;
+  UnionFind un = new UnionFind(len);
+  for (int i = 0; i < len; i++) {
+    // 只处理矩阵右上半部分
+    for (int j = len - 1; j > i; j--) {
+      if (isConnected[i][j] == 1) {
+        un.union(i, j);
+      }
+    }
+  }
+  return un.count();
+}
+
+private static class UnionFind {
+  /**
+   * 连通分量
+   */
+  int size;
+  /**
+   * 每个节点及对应的父节点
+   */
+  int[] parent;
+
+  public UnionFind(int size) {
+    this.size = size;
+    parent = new int[size];
+    for (int i = 0; i < size; i++) {
+      parent[i] = i;
+    }
+  }
+
+  /**
+   * 连通分量
+   */
+  public int count() {
+    return size;
+  }
+
+  /**
+   * a 和 b 建立连接
+   */
+  public void union(int a, int b) {
+    int ap = find(a);
+    int bp = find(b);
+    if (ap == bp) {
+      return;
+    }
+    parent[ap] = bp;
+    size--;
+  }
+
+  /**
+   * 查找节点 a 的根节点
+   */
+  private int find(int a) {
+    int ap = parent[a];
+    if (ap != a) {
+      List<Integer> path = new ArrayList<>();
+      path.add(a);
+      // 向上查找根节点
+      while (ap != parent[ap]) {
+        path.add(ap);
+        ap = parent[ap];
+      }
+      // 路径压缩
+      // 只有一步，无需缩短路径
+      if (path.size() == 1) {
+        return ap;
+      }
+      for (Integer idx : path) {
+        parent[idx] = ap;
+      }
+    }
+    return ap;
+  }
+}
+  // end::answer[]
+}