代码随想录算法训练营第57天|prim算法精讲、kruskal算法精讲

1.prim算法精讲

题目链接：prim算法精讲
文档讲解： 代码随想录

最小生成树是所有节点的最小连通子图，以最小的成本将图中所有节点连接到一起。prim算法是从节点的角度，采用贪心的策略，每次寻找距离 最小生成树最近的节点 并加入到最小生成树中。核心就三步：第一步，选距离生成树最近节点；第二步，最近节点加入生成树；第三步，更新非生成树节点到生成树的距离（即更新minDist数组）。minDist数组用来记录每一个节点距离最小生成树的最近距离，也就是最小生成树的边的权值。

#接收输入
v,e =  map(int,input().split())
#按照常规的邻接矩阵存储图信息，不可达初始化为10001
graph = [[10001] * (v+1) for _ in range(v+1)]
for _ in range(e):
    v1,v2,val = map(int,input().split())
    graph[v1][v2] = val 
    graph[v2][v1] = val 
#定义加入生成树的标记数组和未加入生成树的最近距离
visited = [False] * (v+1)
minDist = [10001] * (v+1)
#循环n-1次，建立n-1次边
#从节点视角来看：每次选中一个节点加入树，更新剩余节点到树的最短距离
#这一步蕴含了确定下一条选取的边，计入总路程ans的计算
for _ in range(1,v+1):
    min_val = 10002 
    cur = -1 
    for j in range(1,v+1):
        if not visited[j] and minDist[j] < min_val:
            cur = j 
            min_val = minDist[j]
    visited[cur] = True
    for j in range(1,v+1):
        if not visited[j] and graph[cur][j] < minDist[j]:
            minDist[j] = graph[cur][j]
ans = 0 
for i in range(2,v+1):
    ans += minDist[i]
print(ans)   

#输出路径
v,e = map(int,input().split())
graph = [[10001] * (v+1) for _ in range(v+1)]
for _ in range(e):
    v1, v2, val = map(int, input().split())
    graph[v1][v2] = val
    graph[v2][v1] = val
visited = [False] * (v+1)
minDist = [10001] * (v+1)
#记录路径
parent = [-1] * (v+1)
for _ in range(1,v+1):
    min_val = 10002
    cur = -1
    for j in range(1,v+1):
        if not visited[j] and minDist[j] < min_val:
            cur = j
            min_val = minDist[j]
    visited[cur] = True
    for j in range(1,v+1):
        if not visited[j] and graph[cur][j] < minDist[j]:
            minDist[j] = graph[cur][j]
            parent[j] = cur
res = 0
for i in range(2,v+1):
    res += minDist[i]
print(res)

for i in range(1,v+1):
    print(f"{i} -> {parent[i]}")

2.kruskal算法精讲

题目链接：kruskal算法精讲
文档讲解： 代码随想录

kruskal是维护边的集合，其思路为，边的权值排序，因为要优先选最小的边加入到生成树中；遍历排序后的边，如果边首尾的两个节点在同一个集合，说明如果连上这条边图会出现环，如果不在同一个集合里，加入最小生成树，并把两个节点加入同一集合。

#kruskal算法
#定义边
class Edge:
    def __init__(self,l,r,val):
        self.l = l 
        self.r = r 
        self.val = val 
n = 10001
father = list(range(n))
def find(u):
    if father[u] == u:
        return u 
    father[u] = find(father[u])
    return father[u]
def joinside(u,v):
    u = find(u)
    v = find(v)
    if u == v:
        return 
    father[v] = u 
def kruskal(edges):
    edges.sort(key = lambda edge: edge.val)
    res = 0
    global father
    father = list(range(n))
    for edge in edges:
        x = find(edge.l) 
        y = find(edge.r) 
        if x != y:
            joinside(x,y)
            res += edge.val
    return res 
if __name__ == "__main__":
    v,e = map(int,input().split())
    edges = []
    for _ in range(e):
        v1,v2,val = map(int,input().split())
        edges.append(Edge(v1,v2,val))
    res = kruskal(edges)
    print(res)