最小生成树

最小生成树（MST）

一个有 n 个结点的连通图的生成树是原图的极小连通子图，且包含原图中的所有 n 个结点，并且有保持图连通的最少的边。

在一给定的无向图G = (V, E) 中，(u, v) 代表连接顶点 u 与顶点 v 的边（即），而 w(u, v) 代表此边的权重，若存在 T 为 E 的子集（即）且为无循环图，使得w(T) 最小，则此 T 为 G 的最小生成树。
最小生成树其实是最小权重生成树的简称。

最小生成树性质

设G=(V，E）是一个连通网络，U是顶点集V的一个非空真子集。若(u，v）是G中一条“一个端点在U中（例如：u∈U），另一个端点不在U中的边（例如：v∈V-U），且（u，v）具有最小权值，则一定存在G的一棵最小生成树包括此边（u，v）。

最小生成树算法

Prim 算法 （普里姆 算法） O(V^2)

///  邻接矩阵 n*n
#include<iostream>
#include<cstring>
using namespace std;
const int INF= 0x3f3f3f3f;
const int maxn=110;
bool vis[maxn];
int lowc[maxn],cost[maxn][maxn];
int prim(int n,int x){
    int ans=0;
    memset(vis,false,sizeof(vis));
    vis[x]=true;
    for(int i=0;i<n;i++) lowc[i]=cost[x][i]; /// 注意是0 - n-1 还是 1 - n !!!
    for(int i=0;i<n;i++){
        if(i==x) continue;
        int minc=INF;
        int p=-1;
        for(int j=0;j<n;j++){       /// MST性质 轻边
            if(!vis[j]&&lowc[j]!=0&&minc>lowc[j]){
                minc=lowc[j];
                p=j;
            }
        }
        if(minc==INF) return -1; /// 原图不联通
        ans+=minc;
        vis[p]=true;
        for(int j=0;j<n;j++){     /// p 点进入 MST, 更新 （MST 性质）
            if(!vis[j]&&cost[p][j]!=0){
                if(lowc[j]==0)   lowc[j]=cost[p][j];
                else if(lowc[j]>cost[p][j])  lowc[j]=cost[p][j];
            }
        }
    }
    return ans;
}
int main(){
    int n,m,x,y,z;
    cin>>n>>m;
    for(int i=1;i<=m;i++){
        cin>>x>>y>>z;
        cost[x][y]=z;
        cost[y][x]=z;
    }
    cout<<prim(n,x)<<endl;
    return 0;
}

Prim 算法 + 堆优化 O(E log(V))

/// 堆优化的prim算法
#include <stdio.h>
#include <string.h>
#include <iostream>
#include <vector>
#include <queue>
#define LL long long
#define N 100000+10 ///最大节点数
#define M 1000000+10 ///最大的边数
///N<=10^5, M<=10^6
using namespace std;
int n, m;
struct node{
    int v, w;
    bool operator<(const node &dd)const{
        return w>dd.w;
    } ///权值小的优先   维护一个小根堆
};
vector<node>q[N];
bool vis[N];
LL ans;
void queue_prim()
{
    priority_queue<node>que;  /// 优先队列 默认大顶堆
    while(!que.empty())
        que.pop();
    ans = 0;
    memset(vis, false, sizeof(vis));
    for(int i=0; i<q[1].size(); i++){
        que.push(q[1][i]);    ///以节点1为起点进行扩展安全边 生成最小树
    }
    vis[1]=true;
    int edge=n-1; ///边数
    node cur;
    while(edge--)
    {
        cur = que.top();
        que.pop();

        if(vis[cur.v]==true){
            while(vis[cur.v]){
                cur=que.top(); que.pop();
            }
        }
        ans+=cur.w; ///printf("%d--  ", cur.w );
        vis[cur.v]=true;
        for(int i=0; i<q[cur.v].size(); i++){
            if(vis[ q[cur.v][i].v ]==false)
                que.push(q[cur.v][i]);
        }
    }
}
int main(){
    scanf("%d%d",&n,&m);
    int i,j;
    int u,v,w;
    node cur;
    for(i=0; i<=n; i++)
        q[i].clear();
    for(i=0; i<m; i++){
       scanf("%d %d %d", &u, &v, &w);
       cur.v=v; cur.w=w;
       q[u].push_back(cur);
       cur.v=u;
       q[v].push_back(cur); ///建立双向边
    }
    queue_prim();
    printf("%lld\n", ans );
    return 0;
}

克鲁斯卡尔(Kruskal)算法 O(E log(E))

// 并查集优化
#include<iostream>
#include<cstring>
#include<algorithm>
using namespace std;
const int maxn=110;
const int maxm=10000;
int F[maxn];
struct Edge{
    int u,v,w;
}edge[maxm];
int tol;
void add(int u,int v,int w){
    edge[tol].u=u;
    edge[tol].v=v;
    edge[tol++].w=w;
}
bool cmp(Edge a,Edge b){
    return a.w<b.w;
}
int find(int x){
    if(F[x]==-1) return x;
    else return F[x]=find(F[x]);
}
int kruskal(int n){
    memset(F,-1,sizeof(F));
    sort(edge,edge+tol,cmp);
    int cnt=0,ans=0;
    for(int i=0;i<tol;i++){
        int u=edge[i].u,v=edge[i].v,w=edge[i].w;
        int t1=find(u),t2=find(v);
        if(t1!=t2){
            ans+=w;
            F[t1]=t2;
            cnt++;
        }
        if(cnt==n-1) break;
    }
    return ans;
}
int main(){
    int n,m,x,y,z;
    cin>>n>>m;
    for(int i=1;i<=m;i++){
        cin>>x>>y>>z;
        add(x,y,z);
    }
    cout<<kruskal(n)<<endl;
    return 0;
}