最小生成树 / 1135. 最低成本联通所有城市（M）

• 最小生成树
  

#
# 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
#
# 返回最小的花费代价使得这n户人家连接起来
# @param n int n户人家的村庄
# @param m int m条路
# @param cost int二维数组 一维3个参数，表示连接1个村庄到另外1个村庄的花费的代价
# @return int
#

#克鲁斯卡尔（选最小边，直至有n-1条边）
class Solution:
    def miniSpanningTree(self , n , m , cost ):
        cost.sort(key=lambda x: x[2])
        # 令最小生成树的初始状态为只有𝑛个顶点而无边的非连通图，
        # 图中每个顶点自成一个连通分量
        p = [i for i in range(n+1)]
        res = 0
        for item in cost:
            if self.find(item[0], p) != self.find(item[1], p): # 判断是否为一个连通分量
                res += item[2]
                p[self.find(item[0], p)] = self.find(item[1], p) # 若不是则合并为同一个
        return res
    
    def find(self, x, p): # 使用并查集来判断连通分量
        if x != p[x]:
            p[x] = self.find(p[x], p)
        return p[x]

# #普里姆算法（选最小边所在的点，直至选完所有顶点）（有BUG）
# class Solution:
#     def miniSpanningTree(self , n , m , cost ):
#         node2 = []
#         maps = [[float("inf") for i in range(n)] for j in range(n)]
#         for item in cost:
#             i = item[0] - 1
#             j = item[1] - 1
#             maps[i][j] = item[2]
#             maps[j][i] = item[2]
#         res = 0
#         node1 = [1]
#         node2 = [i for i in range(2,n+1)]
#         while len(node2) > 0:
#             MIN = float("inf")
#             node_end = 0
#             node_start = 0
#             for i in node1:
#                 for j in node2:
#                     if maps[i-1][j-1] < MIN:
#                         MIN = maps[i-1][j-1]
#                         node_end = j
#                         node_start = i
#             node1.append(node_end)
#             node2.remove(node_end)
#             res += MIN
#         return res

1135.最低成本联通所有城市

• 知乎题解
• 最小生成树Kruskal算法实现 + 联通分量判断 + 并查集贪心实现Kruskal

# 最小生成树Kruskal算法实现 + 联通分量判断 + 并查集贪心实现Kruska
class UnionFind:
    def __init__(self, n):
        self.parent = list(range(n))
        self.cnt = n
 
    def find(self, a):
        acopy = a
        while a != self.parent[a]:
            a = self.parent[a]
        while acopy != a:
            self.parent[acopy], acopy = a, self.parent[acopy]
        return a
 
    def merge(self, a, b):
        if self.find(a) != self.find(b):
            self.parent[self.find(b)] = self.find(a)
            self.cnt -= 1
            return True
        return False # 不能加入此边

class Solution:
    def minimumCost(self, n: int, connections: List[List[int]]) -> int:
        # 建图
        g = defaultdict(list)
        for x, y, c in connections:
            g[x].append(y)
            g[y].append(x)
            
        # 联通分量check
        cnt = 0
        visit = defaultdict(bool)
        
        def dfs(cur):
            nonlocal cnt, visit
            if visit[cur] is True:
                return
            visit[cur] = True
            cnt += 1
            for next_node in g[cur]:
                dfs(next_node)
                
        dfs(1)
        if cnt != n:
            return -1
            
        # 最小生成树Kruskal
        # 取最小的边且不成环（并查集）
        uf = UnionFind(n)
        min_cost = 0
        connections.sort(key = lambda x: x[2])
        for x, y, c in connections:
            if uf.merge(x - 1, y - 1):
                min_cost += c
            if uf.cnt == 1:
                return min_cost