1 const int maxn=1000;
 2 const int INF=1000000000;
 3 int n,G[maxn][maxn];
 4 int d[maxm]; //顶点到集合S的距离
 5 bool vis[maxn]={false};
 6
 7 int prim(){ //默认0号为初始点，函数返回最小生成树的边权之和
 8     fill(d,d+maxn,INF);
 9     d[0]=0;
10     int ans=0; //边权之和
11     for(int i=0;i<n;i++){
12         int u=-1,MIN=INF;
13         for(int j=0;j<n;j++){
14             if(vis[j]==false&&d[j]<MIN){
15                 u=j;
16                 MIN=d[j];
17             }
18         }
19         if(u==-1) return -1;
20         vis[u]=true;
21         ans+=d[u]; //将与集合S距离最小的边加入最小生成树
22         for(int v=0;v<n;v++){
23             if(vis[v]==false && G[u][v]!=INF && G[u][v]<d[v] ){
24                 d[v]=G[u][v]; //以u为中介点可以使v离集合S更近（u已被并入集合）
25             }
26         }
27     }
28     return ans;
29 }

 1 struct Node{
 2     int v,dis;  //v为目标顶点，dis为边权
 3 };
 4 vector<Node> Adj[maxn];
 5 int n,d[maxn];
 6 bool vis[maxn]={false};
 7 int prim(){
 8     fill(d,d+maxn,INF);
 9     d[0]=0;
10     int ans=0;
11     for(int i=0;i<n;i++){
12         int u=-1,MIN=INF;
13         for(int j=0;j<n;j++){
14             if(vis[j]==false && d[j]<MIN){
15                 u=j;
16                 MIN=d[j];
17             }
18         }
19         if(u==-1) return -1;
20         vis[u]=true;
21         ans+=d[u];
22         for(int j=0;j<Adj[u].size();j++){
23             int v=Adj[u][j].v;
24             if(vis[v]==false && Adj[u][j].dis< d[v]){
25                 d[v]=Adj[u][j].dis;
26             }
27         }
28     }
29     return ans;
30 }

 1 const int MAXV=110;
 2 const int MAXE=10010;
 3 int father[MAXV];
 4 int findFather(int x){
 5     int a=x;
 6     while(x!=father[x]){
 7         x=father[x];
 8     }
 9     while(a!=father[a]){
10         int z=a;
11         a=father[a];
12         father[z]=x;
13     }
14     return x;
15 }
16 struct edge{
17     int u,v; //边的两个端点编号
18     int cost; //边权
19 }E[MAXE];
20 bool cmp(edge a,edge b){
21     return a.cost<b.cost;
22 }
23 int kruskal(int n,int m){  //n为顶点个数，m为图的边数
24     int ans=0,Num_Edge=0;
25     for(int i=1;i<=n;i++) father[i]=i; //假设顶点范围为1到n
26     sort(E,E+m,cmp);
27     for(int i=0;i<m;i++){ //枚举边
28         int faU=findFather(E[i].u);
29         int faV=findFather(E[i].v);
30         if(faU!=faV){
31             father[faU]=faV;
32             ans+=E[i].cost;
33             Num_Edge++;
34             if(Num_Edge==n-1) break;
35         }
36     }
37     if(Num_Edge != n-1) return -1;
38     else return ans;
39 }