在边权重为 0 或 1 的完整图中查找 MST 的权重

如果我们需要在边权重为0或1的完整图中查找MST的权重，有很多算法可以实现。下面我们将介绍两种常用的算法：Kruskal算法和Prim算法。

Kruskal算法

Kruskal算法是一种贪心算法，它的基本思想是将所有边按权值从小到大排序，然后依次判断每条边是否在同一个连通分量中，如果不在，则将其加入MST中。这个过程可以用并查集来实现。

#Kruskal算法实现
class UnionFindSet:
    def __init__(self,n):
        self.ufs = [-1]*n
    
    def find_root(self, x):
        if self.ufs[x]<0:
            return x
        else:
            self.ufs[x] = self.find_root(self.ufs[x])
            return self.ufs[x]
    
    def union(self,x,y):
        x_root= self.find_root(x)
        y_root = self.find_root(y)
        if x_root==y_root:
            return False
        if self.ufs[x_root]<self.ufs[y_root]:
            self.ufs[x_root]+=self.ufs[y_root]
            self.ufs[y_root] = x_root
        else:
            self.ufs[y_root]+=self.ufs[x_root]
            self.ufs[x_root] = y_root
        return True
    

def kruskal(n, edges):
    edges.sort(key=lambda x: x[2])
    res = 0
    ufs = UnionFindSet(n)
    for e in edges:
        if ufs.union(e[0],e[1]):
            res+=e[2]
    return res

使用示例：

n = 5
edges = [(0,1,1),(0,2,0),(0,3,1),(0,4,0),(1,2,1),(1,3,1),(1,4,1),(2,3,1),(2,4,1),(3,4,0)]
print(kruskal(n,edges)) #4

Prim算法

Prim算法也是一种贪心算法，它和Dijkstra算法非常相似。其基本思想是在所有的边中，选择一个顶点开始，然后加入与该点相邻且没有加入MST的最小边，直到所有的点都被加入MST。

#Prim算法实现
import heapq

def prim(n, edges):
    res = 0
    visited = [False]*n
    hq = []
    heapq.heappush(hq, [0,0])
    while hq:
        w, v = heapq.heappop(hq)
        if visited[v]:
            continue
        visited[v] = True
        res += w
        for nv, nw in edges[v]:
            if not visited[nv]:
                heapq.heappush(hq, [nw, nv])
    return res

使用示例：

n = 5
edges = [[(1,1),(2,0),(3,1),(4,0)],
         [(0,1),(2,1),(3,1),(4,1)],
         [(0,0),(1,1),(3,1),(4,1)],
         [(0,1),(1,1),(2,1),(4,0)],
         [(0,0),(1,1),(2,1),(3,0)]]
print(prim(n,edges)) #4

以上就是在边权重为0或1的完整图中查找MST的权重的两种算法，它们都具有较好的时间复杂度和可读性，可以根据具体情况选择适合自己的算法实现。