最小生成树（Kruskal、Prim）

Kruskal算法

思想：利用并查集，进行加边操作（每次选择最小权边，直至构成一个生成树）

步骤：

（1）排序：由小到大对边按权值进行排序

（2）当边的数量少于n-1时，重复以下操作：

选择最小权边，如果假如这条权边并不构成回路，那么添加它，否则不添加它

代码模板：

const int MAXN=110;//最大点数 
const int MAXM=10000;//最大边数 
int F[MAXN];//并查集使用 
struct Edge 
{
    int u,v,w; 
}edge[MAXM];//存储边的信息，包括起点/终点/权值 
int tol;//边数，加边前赋值为0 
void addedge(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)//传入点数，返回最小生成树的权值，如果不连通返回-1 
{
    memset(F,-1,sizeof(F));
    sort(edge,edge+tol,cmp);
    int cnt=0;//计算加入的边数
    int ans=0;
    for(int i=0;i<tol;i++)
    {
        int u=edge[i].u;
        int v=edge[i].v;   
        int w=edge[i].w;   
        int t1=find(u);   
        int t2=find(v);   
        if(t1!=t2)   
        {
            ans+=w;
            F[t1]=t2;
            cnt++;
        }
        if(cnt==n-1)
            break;
    }
    if(cnt<n-1)
        return -1;//不连通 
    else return ans;
}  

Prim算法

思想：

从只含一个结点的子图开始构造生成树：

选择连接当前子图和子图外结点的最小权边，将对应结点和边加入子图，直至将所有结点加入子图。

步骤：

1.一个n-1次的循环更新距离数组，存储从起始点到各结点距离，并更改原点和标记数组

2.下面要加入n-1个点，对每次添加，都需要在剩下点中考虑（n个点，没有访问标记的）

3.当然如果某次添加，发现并没有点满足条件，直接跳出返回-1即可

4.每一次添加点后，都需要及时更新一下距离数组

模板：

const int INF=0x3f3f3f3f;
const int MAXN=110;
bool vis[MAXN];
int lowc[MAXN];
int Prim(int cost[][MAXN],int n)//点是0~n-1
{
    int ans=0;
    memset(vis,false,sizeof(vis));
    vis[0]=true;
    for(int i=1; i<n; i++)
        lowc[i]=cost[0][i];
    for(int i=1; i<n; i++)
    {
        int minc=INF;
        int p=-1;
        for(int j=0; j<n; j++)
            if(!vis[j]&&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++)
            if(!vis[j]&&lowc[j]>cost[p][j])
                lowc[j]=cost[p][j];
    }
    return ans;
}

 注意事项

Prim算法时间复杂度是，与图中的边数无关，因此适用于求边稠密的图的最小生成树。

Kruskal算法的时间复杂度是（e是图中边的数目），适合求边稀疏的图的最小生成树。