feat: add solutions to lc problem: No.1584

No.1584.Min Cost to Connect All Points

Author: yanglbme

README.md

@@ -114,6 +114,7 @@
 ### 5. 图论
 
 -   [网络延迟时间](/solution/0700-0799/0743.Network%20Delay%20Time/README.md) - 最短路、Dijkstra 算法、Bellman Ford 算法、SPFA 算法
+-   [连接所有点的最小费用](/solution/1500-1599/1584.Min%20Cost%20to%20Connect%20All%20Points/README.md) - 最小生成树、Prim 算法、Kruskal 算法
 
 <!-- 待补充
 ### 6. 数学知识

README_EN.md

@@ -109,7 +109,8 @@ Complete solutions to [LeetCode](https://leetcode.com/problemset/all/), [LCOF](h
 
 ### 5. Graph Theory
 
--   [Network Delay Time](/solution/0700-0799/0743.Network%20Delay%20Time/README_EN.md) - Shortest Path, Dijkstra, Bellman Ford, SPFA
+-   [Network Delay Time](/solution/0700-0799/0743.Network%20Delay%20Time/README_EN.md) - Shortest Path, Dijkstra's algorithm, Bellman Ford's algorithm, SPFA
+-   [Min Cost to Connect All Points](/solution/1500-1599/1584.Min%20Cost%20to%20Connect%20All%20Points/README_EN.md) - Minimum Spanning Tree, Prim's algorithm, Kruskal's algorithm
 
 <!--
 ### 6. Mathematical Knowledge

solution/0700-0799/0743.Network Delay Time/README.md

@@ -71,7 +71,7 @@
 
 **方法四：SPFA 算法**
 
-时间复杂度，平均情况下 O(m)，最坏情况下 O(nm)，n 表示点数，m 表示边数。
+时间复杂度，平均情况下 O(m)，最坏情况下 O(nm)。
 
 <!-- tabs:start -->
 

solution/1500-1599/1584.Min Cost to Connect All Points/README.md

@@ -69,71 +69,52 @@
 
 <!-- 这里可写通用的实现逻辑 -->
 
-最小生成树 + 并查集。先将所有边按照长度由小到大进行排序，循环遍历每条边，逐个加入到图中，当所有点达到一个连通状态时，退出循环，返回此时的总费用即可。
+最小生成树问题。
 
-模板 1——朴素并查集：
+设 n 表示点数，m 表示边数。
 
-```python
-# 初始化，p存储每个点的父节点
-p = list(range(n))
-
-# 返回x的祖宗节点
-def find(x):
-    if p[x] != x:
-        # 路径压缩
-        p[x] = find(p[x])
-    return p[x]
-
-# 合并a和b所在的两个集合
-p[find(a)] = find(b)
-```
-
-模板 2——维护 size 的并查集：
-
-```python
-# 初始化，p存储每个点的父节点，size只有当节点是祖宗节点时才有意义，表示祖宗节点所在集合中，点的数量
-p = list(range(n))
-size = [1] * n
-
-# 返回x的祖宗节点
-def find(x):
-    if p[x] != x:
-        # 路径压缩
-        p[x] = find(p[x])
-    return p[x]
+**方法一：朴素 Prim 算法**
 
-# 合并a和b所在的两个集合
-if find(a) != find(b):
-    size[find(b)] += size[find(a)]
-    p[find(a)] = find(b)
-```
+时间复杂度 O(n²)。
 
-模板 3——维护到祖宗节点距离的并查集：
+**方法二：Kruskal 算法**
 
-```python
-# 初始化，p存储每个点的父节点，d[x]存储x到p[x]的距离
-p = list(range(n))
-d = [0] * n
-
-# 返回x的祖宗节点
-def find(x):
-    if p[x] != x:
-        t = find(p[x])
-        d[x] += d[p[x]]
-        p[x] = t
-    return p[x]
-
-# 合并a和b所在的两个集合
-p[find(a)] = find(b)
-d[find(a)] = distance
-```
+先将所有边按照长度由小到大进行排序，循环遍历每条边，逐个加入到图中，当所有点达到一个连通状态时，退出循环，返回此时的总费用即可。
 
 <!-- tabs:start -->
 
 ### **Python3**
 
 <!-- 这里可写当前语言的特殊实现逻辑 -->
 
+```python
+class Solution:
+    def minCostConnectPoints(self, points: List[List[int]]) -> int:
+        INF = 0x3f3f3f3f
+        n = len(points)
+        g = [[0] * n for _ in range(n)]
+        for i in range(n):
+            for j in range(n):
+                if i != j:
+                    x1, y1 = points[i]
+                    x2, y2 = points[j]
+                    g[i][j] = abs(x1 - x2) + abs(y1 - y2)
+        dist = [INF] * n
+        vis = [False] * n
+        ans = 0
+        for i in range(n):
+            t = -1
+            for j in range(n):
+                if not vis[j] and (t == -1 or dist[t] > dist[j]):
+                    t = j
+            if i:
+                ans += dist[t]
+            for j in range(n):
+                dist[j] = min(dist[j], g[t][j])
+            vis[t] = True
+        return ans
+```
+
 ```python
 class Solution:
     def minCostConnectPoints(self, points: List[List[int]]) -> int:
@@ -168,6 +149,46 @@ class Solution:
 
 <!-- 这里可写当前语言的特殊实现逻辑 -->
 
+```java
+class Solution {
+    private static final int INF = 0x3f3f3f3f;
+
+    public int minCostConnectPoints(int[][] points) {
+        int n = points.length;
+        int[][] g = new int[n][n];
+        int[] dist = new int[n];
+        boolean[] vis = new boolean[n];
+        for (int i = 0; i < n; ++i) {
+            for (int j = 0; j < n; ++j) {
+                if (i != j) {
+                    int x1 = points[i][0], y1 = points[i][1];
+                    int x2 = points[j][0], y2 = points[j][1];
+                    g[i][j] = Math.abs(x1 - x2) + Math.abs(y1 - y2);
+                }
+            }
+        }
+        Arrays.fill(dist, INF);
+        int ans = 0;
+        for (int i = 0; i < n; ++i) {
+            int t = -1;
+            for (int j = 0; j < n; ++j) {
+                if (!vis[j] && (t == -1 || dist[t] > dist[j])) {
+                    t = j;
+                }
+            }
+            if (i > 0) {
+                ans += dist[t];
+            }
+            for (int j = 0; j < n; ++j) {
+                dist[j] = Math.min(dist[j], g[t][j]);
+            }
+            vis[t] = true;
+        }
+        return ans;
+    }
+}
+```
+
 ```java
 class Solution {
     private int[] p;
@@ -212,6 +233,48 @@ class Solution {
 
 ### **C++**
 
+```cpp
+class Solution {
+public:
+    const int inf = 0x3f3f3f3f;
+
+    int minCostConnectPoints(vector<vector<int>>& points) {
+        int n = points.size();
+        vector<vector<int>> g(n, vector<int>(n));
+        vector<int> dist(n, inf);
+        vector<bool> vis(n);
+        for (int i = 0; i < n; ++i)
+        {
+            for (int j = 0; j < n; ++j)
+            {
+                if (i !=  j)
+                {
+                    int x1 = points[i][0], y1 = points[i][1];
+                    int x2 = points[j][0], y2 = points[j][1];
+                    g[i][j] = abs(x1 - x2) + abs(y1 - y2);
+                }
+            }
+        }
+        int ans = 0;
+        for (int i = 0; i < n; ++i)
+        {
+            int t = -1;
+            for (int j = 0; j < n; ++j)
+            {
+                if (!vis[j] && (t == -1 || dist[t] > dist[j]))
+                {
+                    t = j;
+                }
+            }
+            if (i) ans += dist[t];
+            for (int j = 0; j < n; ++j) dist[j] = min(dist[j], g[t][j]);
+            vis[t] = true;
+        }
+        return ans;
+    }
+};
+```
+
 ```cpp
 class Solution {
 public:
@@ -253,6 +316,58 @@ public:
 
 ### **Go**
 
+```go
+func minCostConnectPoints(points [][]int) int {
+	n := len(points)
+	inf := 0x3f3f3f3f
+	g := make([][]int, n)
+	dist := make([]int, n)
+	vis := make([]bool, n)
+	for i, p1 := range points {
+		dist[i] = inf
+		g[i] = make([]int, n)
+		for j, p2 := range points {
+			if i != j {
+				x1, y1 := p1[0], p1[1]
+				x2, y2 := p2[0], p2[1]
+				g[i][j] = abs(x1-x2) + abs(y1-y2)
+			}
+		}
+	}
+	ans := 0
+	for i := 0; i < n; i++ {
+		t := -1
+		for j := 0; j < n; j++ {
+			if !vis[j] && (t == -1 || dist[t] > dist[j]) {
+				t = j
+			}
+		}
+		if i > 0 {
+			ans += dist[t]
+		}
+		for j := 0; j < n; j++ {
+			dist[j] = min(dist[j], g[t][j])
+		}
+		vis[t] = true
+	}
+	return ans
+}
+
+func min(a, b int) int {
+	if a < b {
+		return a
+	}
+	return b
+}
+
+func abs(x int) int {
+	if x < 0 {
+		return -x
+	}
+	return x
+}
+```
+
 ```go
 var p []int