最小生成树

最小生成树

Prim

朴素Prim O(n²)

堆优化Prim O(mlogn)

Kruskal O(mlogm)

Prim

//模板
int n;      // n表示点数
int g[N][N];        // 邻接矩阵，存储所有边
int dist[N];        // 存储其他点到当前最小生成树的距离
bool st[N];     // 存储每个点是否已经在生成树中


// 如果图不连通，则返回INF(值是0x3f3f3f3f), 否则返回最小生成树的树边权重之和
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;

        if (i && dist[t] == INF) return INF;

        if (i) res += dist[t];
        st[t] = true;

        for (int j = 1; j <= n; j ++ ) dist[j] = min(dist[j], g[t][j]);
    }

    return res;
}

//Prim算法求最小生成树
#include<iostream>
#include<algorithm>
#include<cstring>

using namespace std;
const int N = 510, INF = 0x3f3f3f3f;
int n,m;
int g[N][N],dis[N];
bool st[N];

int prim(){
    memset(dis,0x3f,sizeof dis);
    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||dis[j]<dis[t]))
                t=j;
        }
        //printf("%d\n%d",t,dis[t]);
        if(i&&dis[t] == INF) return INF;
        if(i) res+=dis[t];
        st[t] = true;
        for(int j = 1;j<=n;j++) dis[j] = min(dis[j],g[t][j]);
    }
    return res;
}

int main(){
    cin>>n>>m;
    int a,b,c;
    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;
        }
        
    while(m--){
        cin>>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",t);
    
    return 0;
}

Kruskal

//模板
int n, m;       // n是点数，m是边数
int p[N];       // 并查集的父节点数组

struct Edge     // 存储边
{
    int 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;
    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 INF;
    return res;
}

//Kruskal算法求最小生成树
#include<iostream>
#include<cstring>
#include<algorithm>

using namespace std;
const int N = 2e5+10,M = 2e5+10;
int n,m;
int p[M];
struct Edge{
    int a,b,w;
    bool operator < (const Edge & W)const{
        return w<W.w;
    }
}edges[N];

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

int Kruskal(){
    int res = 0,cnt = 0;
    for(int i = 0;i<m;i++){
        int a = edges[i].a;
        int b = edges[i].b;
        int w = edges[i].w;
        
        if(find(a)!=find(b)){
            p[find(a)] = p[find(b)];
            cnt++;
            res+=w;
        }
    }
    if(cnt==n-1) return res;
    else return 0x3f3f3f3f;
}

int main(){
    cin>>n>>m;
    int a,b,w;
    for(int i = 0;i<n;i++) p[i] = i;
    for(int i = 0;i<=m;i++){
        cin>>a>>b>>w;
        edges[i] = {a,b,w};
    }
    sort(edges,edges+m);
    int t = Kruskal();
    
    if(t==0x3f3f3f3f) puts("impossible");
    else printf("%d",t);
    
    return 0;
}

vscode迁移