Prim算法和Kruskal算法求最小生成树

生成树：连通图的包含图中的所有顶点的极小连通子图。

最小生成树：最小生成树其实是 最小权重生成树 的简称。原图中边的权值最小的生成树，所谓最小是指边的权值之和小于或者等于其它生成树的边的权值之和。

求最小生成树：修路连通问题。

Prim算法

①朴素Prim。算法流程和dijkstra算法非常相似。dijkstra算法：1.先将所有点到1号点的距离dist[i]初始化为正无穷。2。迭代n此，每次寻找当前不在集合中距离最小的点t。3.找到t后，用t更新其他点到1号点的距离。4.然后将t加入已经确定了最短距离的点的集合st

②prim算法：

dist[t]表示t点到已存在的连通图(集合)的距离。

1.先将所有点的距离初始化为正无穷：

。

2.n次迭代，每次找到不在集合(prim算法的集合是当前的生成树(连通块))中距离的最近的点赋给t，然后用t更新其他点到集合的距离，再把t加到集合st中。

for(i = 0;i < n;i ++)

st[t] = true

其他点到集合的距离：看看其他点有没有一条边可以连到集合内部，找到这个点到集合内部的边中长度最小的边，这个最短的距离就称为这个点到集合的距离，如果没有一条边连到集合内部，那么这个点到集合的距离就定义为正无穷。

模板题链接：858. Prim算法求最小生成树 - AcWing题库

无向稠密图，边的数量和点的数量的平方基本相当。稠密图用邻接矩阵存储。

模板题代码：

#include <iostream>
#include <cstring>
#include <algorithm>

using namespace std;

const int N = 510,INF = 0x3f3f3f3f;//定义正无穷

int n,m;
int g[N][N];
int dist[N];
bool st[N];

int prim(){
    memset(dist,0x3f,sizeof dist);
    
    int res = 0;//res存最小生成树里面所有边的长度之和
    //n次迭代
    for(int i = 0;i < n;i ++){
        int t = -1;
        for(int j = 1;j <= n;j ++)
            //在集合外并且当前还没有找到任何一个点或者t的距离大于当前j的距离
            if(!st[j] && (t == -1 || dist[t] > dist[j]))t = j;
            
            //如果不是第一个点或者dist[t]为正无穷，说明当前距离最近的点到集合的距离都为正无穷，图示不连通的，不存在最小生成树
            if(i && dist[t] == INF)return INF;
            //先累加再更新，避免将自环加入最小生成树，因为最小生成树不应该有环。
            if(i)res += dist[t];
            for (int j = 1; j <= n; j ++ )dist[j] = min(dist[j],g[t][j]);
            
            st[t] = true;
    }
    return res;
}

int main()
{
    scanf("%d%d", &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 == INF)puts("impossible");//所有点不连通，不存在生成树；
    else printf("%d\n",t);
    
    return 0;
}

Kruskal算法

稀疏图中用kruskal算法就够了。

①将所有边按权重从小到大排序。(可以用快排/sort函数)O(mlogm)，Kruskal算法的瓶颈(最慢的部分）

②从小到大枚举每条边ab，权重为c，如果a和b不连通，就将这条边加入集合中（实际上就是在a和b之间加一条边，参考并查集：837. 连通块中点的数量 - AcWing题库 只用到了本题中的前两个操作，并查集很快，每次o(1)，时间复杂度o(m)）并查集的简单应用。

模板提链接：859. Kruskal算法求最小生成树 - AcWing题库

不需要用邻接表或邻接矩阵来存图，用一个结构体即可，只需要把每条边存下来就可以了，不需要用到复杂的数据结构。

模板题代码实现：

#include <cstring>
#include <iostream>
#include <algorithm>

using namespace std;

const int N = 100010, M = 200010, INF = 0x3f3f3f3f;

int n, m;
int p[N];

struct Edge
{
    int a, b, w;//点a和b之间存在权重为w的边

    //？？重载一下小于号？？方便按权重排序。
    bool operator< (const Edge &W)const
    {
        return w < W.w;
    }
}edges[M];

int find(int x)
{
    if (p[x] != x) p[x] = find(p[x]);
    return p[x];
}

int kruskal()
{
    //第一步把所有边排序
    sort(edges, edges + m);

    //第二步初始化并查集
    for (int i = 1; i <= n; i ++ ) p[i] = i;

    int res = 0, cnt = 0;//res存的是最小生成树中所有数边的权重之和，cnt存当前加了多少条边。
    
    //从小到大枚举所有边
    for (int i = 0; i < m; i ++ )
    {
        int a = edges[i].a, b = edges[i].b, w = edges[i].w;

        //让a等于a的祖宗节点，b等于b的祖宗节点，判断a和b是否连通，就是判断a和b的祖宗节点是否相同
        a = find(a), b = find(b);
        
        //如果两个祖宗节点不连通就把这条边加进集合
        if (a != b)
        {
            p[a] = b;//将两个点所在的集合合并
            res += w;
            cnt ++ ;
        }
    }

    //如果加入的边数少于n-1说明这个图不是连通的
    if (cnt < n - 1) return INF;
    return res;
}

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

    for (int i = 0; i < m; i ++ )
    {
        int a, b, w;
        scanf("%d%d%d", &a, &b, &w);//读入所有边
        edges[i] = {a, b, w};
    }

    int t = kruskal();

    if (t == INF) puts("impossible");
    else printf("%d\n", t);

    return 0;
}