最小生成树

<前导>

• 最小生成树必须包含图中所有顶点，且边也来自图中，并使树中的边权之和最小；
• 最小生成树是树，满足边数等于顶点数减一，且树内一定不会有环；
• 对任意一个图来说，最小生成树可以不唯一，但其边权之和一定是唯一的；
• 最小生成树是针对于无向图来说的；
• 求解最小生成树有两种算法：prim算法、kruskal算法；

<prim算法>

与最短路径不一样，树可以有很多分支，因此只需要保证任意两个顶点之间的距离是最小的，然后遍历所有顶点，就能够得到最小生成树；

int n,G[maxn][maxn];
int d[maxn];
bool book[maxn]={false};
int prim(int s){
    int rel=0;//边权之和
    for(int i=0;i<n;i++){
        d[i]=inf;
    }
    d[s]=0;
    for(int i=0;i<n;i++){
        int u,mind=inf;
        for(int j=0;j<n;j++){
            if(book[j]==false&&d[j]<mind){
                u=j;
                mind=d[j];
            }
        }
        book[u]=true;
        rel+=d[u];
        for(int v=0;v<n;v++){
            if(book[v]==false&&G[u][v]<inf&&G[u][v]<d[v])
                d[v]=G[u][v];
        }
    }
    return rel;
}

<kruskal算法>

struct edge{
    int u,v;
    int dis;
}e[maxn]; //注意这里定义的是边
bool cmp(edge a,edge b){
    return e.dis<b.dis;
}
int n,m;
int father[maxn];
int findf(int x){
    if(x==father[x]) return x;
    else{
        int F=findf(father[x]);
        father[x]=F;
        return F;
    }
}
int kruskal(int n,int m){
    int rel=0,num=0;
    for(int i=0;i<n;i++){
        father[i]=i;
    }
    sort(e,e+m,cmp);
    for(int i=0;i<m;i++){
        int fu=findf(e[i].u);
        int fv=findf(e[i].v);
        if(fu!=fv){
            father[fu]=fv;
            rel+=e[i].dis;
            num++;
            if(num==n-1) break;
        }
    }
    if(num!=n-1) return -1;
    return rel;
}