2021年hznu寒假集训第十天 最小生成树入门

2021年hznu寒假集训第十天

什么是最小生成树

给定一张边带权的无向联通图G = (V,E), n = |V|,m=|E|。由V中全部顶点和E中n-1条边构成的无向联通子图被称为G的一棵生成树。边的权值之和最小的的生成树被称为无向图G的最小生成树（Minimum Spanning Tree,MST）

畅通工程

Kruskal算法

其基本思想是：假设连通网G=（V，E），令最小生成树的初始状态为只有n个顶点而无边的非连通图T=（V，{}），图中每个顶点自成一个连通分量。在E中选择代价最小的边，若该边依附的顶点分别在T中不同的连通分量上，则将此边加入到T中；否则，舍去此边而选择下一条代价最小的边。依此类推，直至T中所有顶点构成一个连通分量为止。
通俗点讲：Kruskal算法在找最小生成树结点之前，需要对边权重从小到大进行排序。将排序好的权重边依次加入到最小生成树中（如果加入时产生回路就跳过这条边，加入下一条边），当加入的边数为n - 1条后，就找到了这个连通图的最小生成树。




怎样才能判断我们加入一条边是否会形成环呢？
就要用到我们前面学到的并查集。

具体流程

1.建立并查集，每个点各自构成一个集合。
2.把所有边按照权值从小到大排序，依次扫描每条边（x,y, z）。
3.若x,y属于同一个集合（x,y已联通），则忽略这条边，继续扫描下一条。
4.否则，合并x,y所在的集合，并把z累加到答案中。
5.所有边扫描完成后，第4步中处理过的边就构成最小生成树。

#include<bits/stdc++.h>
using namespace std;
const int maxn = 110;
struct Edge{
    int u, v, w;
    bool operator < (const Edge &r)const{     //边权从小到大排序
        return w < r.w;
    }
}E[maxn * maxn];
int n, m, f[maxn];
int find(int x) {
    return x == f[x] ? x : f[x] = find(f[x]);
}
void Kruskal(int n, int m) {
    int res = 0;      // 存放结果
    int num = 0;      // 记录当前选择了多少条边
    sort(E + 1, E + 1 + m);
    for(int i = 1; i <= n; i++) f[i] = i;     //初始化 每个点自己为一个集合
    for(int i = 1; i <= m; i++) {
        int f1 = find(E[i].u);           //  查询u顶点在哪个集合中
        int f2 = find(E[i].v);           //  查询v顶点在哪个集合中
        if(f1 != f2) {                   //  如果不在同一个集合中
            num++;                       //  选中的边数 +1
            res += E[i].w;               //  答案加上这条边的权值
            f[f1] = f2;                  //  将这两个点合并到一个集合中
        }
        if(num == n - 1)                 // 如果已经找到了 n - 1条边，说明最小生成树已经构建完成了
            break;
    }
    if(num == n - 1) printf("%d\n", res);
    else  puts("?");
}
int main() {
    while(~scanf("%d %d", &m, &n)) {
        if(m == 0) break;
        for(int i = 1; i <= m; i++)
            scanf("%d%d%d", &E[i].u, &E[i].v, &E[i].w);
        Kruskal(n, m);
    }
    return 0;
}

prim算法

在任意时刻，设已经确定属于最小生成树的结点集合为T,剩余节点集合为S,每次找到最小的一条边（x,y,z）,满足x∈S,y∈T。即两个端点分别属于S,T的权值最小的边，然后把点x从S中删除加入到集合T中，并把z累加到答案中。
通俗点讲：Prim算法从任意一个顶点开始生成最小生成树，每次选择一个与当前小树最近的一个顶点，并将这个顶点加入到小树中。然后更新这棵小树到其他点的最近距离。

具体实现

1.选用图中的任意一个顶点V0,从V0开始生成最小生成树：
2.初始化d[v0]=0,其他点的距离值d[i]=正无穷；其中d [ i ] 表示当前这棵小树到其他点的最小距离值。
3. 经过N次如下步骤操作，最后得到一个含N个顶点，N-1条边的最小生成树: 1>选择一个未标记的点K，并且d [ k ] 的值是最小的；
2>标记点K进入这棵小树;
3>以K为中间点，更新这棵小树到未标记点的距离的最小值；
4.得到最有生成树T。

#include<bits/stdc++.h>
using namespace std;
const int maxn = 110;
#define inf 0x3f3f3f3f
int n, m, G[maxn][maxn], vis[maxn], d[maxn];
void Prim(int n, int m) {
    memset(vis, 0, sizeof(vis));
    int index = 1;       // 当前加入到小树的顶点
    int res = 0;         //  存放结果
    vis[index] = 1;
    for(int i = 1; i <= n; i++)    // 更新这个点到其他点的距离  
        d[i] = G[index][i];
    for(int i = 1; i < n; i++) {           // 执行 n - 1 次， 找剩下的n - 1 个点
        int minn = inf;
        for(int j = 1; j <= n; j++) {        // 找出未加入小树且 d 最小的点
            if(!vis[j] && d[j] < minn) {
                minn = d[j];
                index = j;
            }
        }
        if(minn == inf) {             // 如果没有找到， 说明不存在最小生成树
            puts("?");
            return ;
        }
        res += minn;          // 累加答案
        vis[index] = 1;       // 将这个点加入最小生成树中
        for(int j = 1; j <= n; j++) {                // 更新这个点加入后，当前这棵小树到未加入的点的最近距离
            if(!vis[j] && d[j] > G[index][j])  d[j] = G[index][j];
        }
    }
    printf("%d\n", res);
}
int main() {
    while(~scanf("%d%d", &m, &n)) {
        if(m == 0) break;
        for(int i = 1; i <= n; i++) {       // 邻接矩阵的初始化
            for(int j = 1; j <= n; j++) {
                if(i == j) G[i][j] = 0;
                else G[i][j] = inf;
            }
        }
        for(int i = 1, u, v, w; i <= m; i++) {
            scanf("%d%d%d", &u, &v, &w);
            G[u][v] = G[v][u] = min(w, G[u][v]);        // 消除重边的影响
        }
        Prim(n, m);
    }
    return 0;
}

Prim算法和Kruskal算法的区别对比

从策略上来说，Prim算法是直接查找，多次寻找邻边的权重最小值，而Kruskal是需要先对权重排序后查找的。 所以说，Kruskal在算法效率上是比Prim快的，因为Kruskal只需一次对权重的排序就能找到最小生成树，而Prim算法需要多次对邻边排序才能找到