【算法基础】最小生成树——Prim算法、Kruskal算法

Prim算法

算法描述：其实与Dijkstra算法有些相似，先找到第一个点，然后找到离这个点最近的点。更加普遍一点的说，我们以我们找到的集合为基础，再找到不在集合中且离集合最近的点，将这个点加入到集合中。

dist数组表示这个点在加入集合时离集合的距离，规范来说就是表示 i 节点到连通部分的最短距离。

st表示这个点是否在集合中。

#include<iostream>
#include<cstring>

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

int prim()
{
    memset(dist,0x3f,sizeof(dist));
    int res=0;
    //这里不需要初始化dist[1]=0,因为在后面会判断当前的点是否为第一个点
    // dist[1]=0;
    //res中是不会加上到第一个点的距离的
    
    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;
}

int main()
{
    memset(g,0x3f,sizeof(g));
    
    scanf("%d%d",&n,&m);
    
    for(int i=0;i<m;i++)
    {
        int a,b,c;
        scanf("%d%d%d",&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\n",t);
    
    return 0;
}

Kruskal算法

算法描述：如果说Prim算法是以点为核心，那么Kruskal算法就是以边的核心的。

首先，我们需要对所有的边从小到大排序。

然后从小到大遍历所有的边，如果遍历到的这条边的两个结点之间在集合内是不互通的，则加入集合，否则跳过。（反过来想，如果这两个点互通，说明在原来的集合中已经有更短的边让这两个互通了，所以跳过。）

对于互通不互通的判断，我们使用并查集来存储一个图的连通块。

//用于稀疏图，（加边）
#include<iostream>
#include<cstring>
#include<algorithm>

using namespace std;
const int N=1e5+10,M=2e5+10,INF=0x3f3f3f3f;
int 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(x!=p[x]) return 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;
}
int main()
{
    scanf("%d%d",&n,&m);
    
    for(int i=0;i<m;i++)
    {
        int a,b,w;
        scanf("%d%d%d",&a,&b,&w);
        edges[i]={a,b,w};
    }
    
    int t=kruskal();
    
    if(t==INF)puts("impossible");
    else printf("%d\n",t);
    
    return 0;
}

但是，一定要注意在输入边时不能用下边的代码，具体原因不清楚，大概是因为auto用法导致的

for(int i=0;i<m;i++)
{
    auto j = edges[i];
    scanf("%d%d%d",&j.a,&j.b,&j.w);//不能这样赋值!!!
}

补充

Sort后面的参数
1. 函数指针，自己实现cmp函数：

bool cmp(struct Edge A, struct Edge B)
{
return A.w < B.w;
}
//然后sort里加个参数 ： sort(edges, edges + m,cmp);

2. 类的仿函数，定义一个类，里面直接bool operator(){…}

该代码中使用的就是仿函数
3. lambda函数，[] (const int u,const int v){return u.w < v.w ;}