两个常用最小生成树算法

Kruskal

思路

对边从小到大排序，使用并查集逐个连接边所对应的两个点，如果还不在集合里就连接，在集合里就不需要再次连了，最后并查集里的点就对应最小生成树的点。

正确性

最小生成树里有最小边权覆盖所有点的边，由于我们连接时按照从小到大的顺序相连，那么两个点连接的一定是最短的那条边，所以就是最小生成树

代码

/*
 * @Author: ACCXavier
 * @Date: 2021-05-13 21:43:18
 * @LastEditTime: 2021-05-13 22:14:27
 * Bilibili:https://space.bilibili.com/7469540
 * 题目地址:https://www.acwing.com/problem/content/description/861/
 * @keywords: Kruskal求最小生成树
 * 
先对边从小到大排序,然后从最短边开始遍历,如果两条边对应点不在一个集合中则加入到一个集合中.
如果最后cnt<n-1说明连接的次数小于n-1,表示有点没连上,则不存在最小生成树
 */

#include <algorithm>
#include <iostream>
using namespace std;

const int N = 100010, M = 200010;

int n, m;
int p[N];

struct Edge {
    int a, b, w;
    bool operator<(const Edge &A) const {
        return w < A.w;
    }
} edges[M];//!边数开到m

int find(int x) {
    return p[x] == x ? x : p[x] = find(p[x]);  //写成两行别忘记return
}

int kruskal() {
    sort(edges, edges + m);
    for (int i = 1; i <= n; ++i) p[i] = i;  //@初始化并查集
    int res = 0,                            //边权和
        cnt = 0;                            //连接的点的数量
    for (int i = 0; i < m; ++i) {
        int a = edges[i].a, b = edges[i].b, w = edges[i].w;
        a = find(a), b = find(b);
        if (a != b) {  //非同根合并
            p[a] = b;
            res += w;
            cnt++;
        }
    }
    if (cnt < n - 1) return -1;  //不存在生成树
    return res;
}

int main() {
    scanf("%d%d", &n, &m);

    int a, b, w;
    for (int i = 0; i < m; ++i) {
        scanf("%d%d%d", &a, &b, &w);
        edges[i] = {a, b, w};
    }
    
    int t = kruskal();
    if (t == -1) puts("impossible");
    else printf("%d\n", t);

    return 0;
}

Prim

思路

维护一个集合S,每次将距离集合最近的点加入集合,并更新其他点到集合的距离(djikstra是更新到起始点的距离),最后的集合就是最小生成树.

正确性

见算法导论P363页,较为冗长.网上博客写的又乱七八糟的,建议不看.不懂正确性也没关系.

代码

/*
 * @Author: ACCXavier
 * @Date: 2021-04-23 11:32:18
 * @LastEditTime: 2021-06-27 10:20:54
 * Bilibili:https://space.bilibili.com/7469540
 * 题目地址:https://www.acwing.com/problem/content/860/
 * @keywords: Prim算法求最小生成树
给定一个 n 个点 m 条边的无向图，图中可能存在重边和自环，边权可能为负数。
求最小生成树的树边权重之和，如果最小生成树不存在则输出 impossible。
给定一张边带权的无向图 G=(V,E)，其中 V 表示图中点的集合，E
表示图中边的集合，n=|V|，m=|E|。 由 V 中的全部 n 个顶点和 E 中 n?1
条边构成的无向连通子图被称为 G
的一棵生成树，其中边的权值之和最小的生成树被称为无向图 G 的最小生成树。 输入格式
第一行包含两个整数 n 和 m。
接下来 m 行，每行包含三个整数 u,v,w，表示点 u 和点 v 之间存在一条权值为 w 的边。
输出格式
共一行，若存在最小生成树，则输出一个整数，表示最小生成树的树边权重之和，如果最小生成树不存在则输出
impossible。 数据范围 1≤n≤500, 1≤m≤105, 图中涉及边的边权的绝对值均不超过 10000。
输入样例：
4 5
1 2 1
1 3 2
1 4 3
2 3 2
3 4 4
输出样例：
6
@Dijkstra算法是更新到起始点的距离，Prim是更新到集合S的距离
 */
#include <cstring>
#include <iostream>
using namespace std;
const int N = 510, INF = 0x3f3f3f3f;

int n, m;
int g[N][N];  //稠密图,用矩阵
int dist[N];  // dist[j]表示第j个点到集合S最小距离

bool st[N];
int pre[N];  //前驱结点
int prim() {
    memset(dist, 0x3f, sizeof dist);
    int res = 0;

    for (int i = 0; i < n; ++i) {
        int t = -1;
        for (int j = 1; j <= n; ++j) {
            if (!st[j] && (t == -1 || dist[t] > dist[j]))
                t = j;  //找距离集合S最近的点
        }
        if (i && dist[t] == INF) return -1;  //不是第一个点时,距离集合最近的点距离为无穷,说明不连通,不存在最小生成树
        if (i) res += dist[t];               //第一个点dist还不存在
        st[t] = true;                        //加入集合
        for (int j = 1; j <= n; ++j)
            if(!st[j]) //更新不在st中的
            dist[j] = min(dist[j], g[t][j]);  //用t更新其他点到s集合的距离
        //$记录路径的写法:

        // for (int j = 1; j <= n; ++j) {
        //     if (dist[j] > g[t][j]) {
        //         dist[j] = g[t][j];
        //         pre[j] = t;
        //     }
        // }
    }
    return res;
}

void getpath()  //输出各个边
{
    for (int i = n - 1; i >= 1; i--)  //n 个节点，所以有 n-1 条边。
    {
        cout << i << " " << pre[i] << " " << endl;  // i 是节点编号，pre[i] 是 i 节点的前驱节点。他们构成一条边。
    }
}

int main() {
    cin >> n >> m;
    memset(g, 0x3f, sizeof g);

    while (m--) {
        int a, b, c;
        scanf("%d%d%d", &a, &b, &c);
        g[a][b] = g[b][a] = min(g[a][b], c);
    }

    int t = prim();
    if (t == -1)
        puts("impossible");
    else
        printf("%d\n", t);
 //   getpath();

    return 0;
}