求最小生成树

稠密图——Prim算法

基本思路：

贪心的策略，循环n次，每次找到未选过的dist最小的点，用该dist去更新其他dist，最终dist[n]就是最小生成树的权之和

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

const int N = 510;
int g[N][N];//存储图
int dt[N];//存储各个节点到生成树的距离
int st[N];//节点是否被加入到生成树中
int pre[N];//节点的前去节点
int n, m;//n 个节点，m 条边

void prim()
{
    memset(dt,0x3f, sizeof(dt));//初始化距离数组为一个很大的数（10亿左右）
    int res= 0;
    dt[1] = 0;//从 1 号节点开始生成 
    for(int i = 0; i < n; i++)//每次循环选出一个点加入到生成树
    {
        int t = -1;
        for(int j = 1; j <= n; j++)//每个节点一次判断
        {
            if(!st[j] && (t == -1 || dt[j] < dt[t]))//如果没有在树中，且到树的距离最短，则选择该点
                t = j;
        }

        //2022.6.1 发现测试用例加强后，需要判断孤立点了
        //如果孤立点，直返输出不能，然后退出
        if(dt[t] == 0x3f3f3f3f) {
            cout << "impossible";
            return;
        }


        st[t] = 1;// 选择该点
        res += dt[t];
        for(int i = 1; i <= n; i++)//更新生成树外的点到生成树的距离
        {
            if(dt[i] > g[t][i] && !st[i])//从 t 到节点 i 的距离小于原来距离，则更新。
            {
                dt[i] = g[t][i];//更新距离
                pre[i] = t;//从 t 到 i 的距离更短，i 的前驱变为 t.
            }
        }
    }

    cout << res;

}

void getPath()//输出各个边
{
    for(int i = n; i > 1; i--)//n 个节点，所以有 n-1 条边。

    {
        cout << i <<" " << pre[i] << " "<< endl;// i 是节点编号，pre[i] 是 i 节点的前驱节点。他们构成一条边。
    }
}

int main()
{
    memset(g, 0x3f, sizeof(g));//各个点之间的距离初始化成很大的数
    cin >> n >> m;//输入节点数和边数
    while(m --)
    {
        int a, b, w;
        cin >> a >> b >> w;//输出边的两个顶点和权重
        g[a][b] = g[b][a] = min(g[a][b],w);//存储权重
    }

    prim();//求最下生成树
    //getPath();//输出路径
    return 0;
}

代码转自：AcWing 858. Prim算法求最小生成树：图解+详细代码注释（带上了保存路径） - AcWing

稀疏图——kruskal算法（struct存储，应用并查集）

基本思路：

将边按权值从小到大排序，遍历边的数组，如果边中的两点的祖先不同，就将该边加入到最小生成树中，如果祖先相同，就说明最小生成树中已经存在包括这两个点的更优解，则跳过。

设置一个计数器，每次加入新边时，cnt++，如果循环结束，cnt <n-1，则说明有孤立的连通块，无最小生成树。

#include <bits/stdc++.h>
using namespace std;

const int N = 2 * 1e5 + 10;

int n, m;
int p[N];
struct Edge{
    int a, b, w;
}edges[N];

bool cmp(Edge a, Edge b)
{
    return a.w < b.w;
}

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

int kruskal()
{
    sort(edges + 1, edges + m + 1, cmp);
    for(int i = 1; i <= n; i ++) p[i] = i;

    int cnt = 0, res = 0;

    for(int i = 1; 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 0x3f3f3f3f;
    return res;
}

int main()
{
    cin >> n >> m;
    for(int i = 1; i <= m; i ++)
    {
        int a, b, w;
        cin >> a >> b >> w;
        edges[i] = {a, b, w};
    }

    int t = kruskal();

    if(t != 0x3f3f3f3f) cout << t << endl;
    else cout << "impossible" << endl;
}