Boruvka算法求最小生成树

学习了一个新的最小生成树的算法，Boruvka（虽然我不知道怎么读）。算法思想也是贪心，类似于Kruskal。

大致是这样的，我们维护图中所有连通块，然后遍历所有的点和边，找到每一个连通块和其他连通块相连的最小的一条边，然后把连通块合并起来，重复这个操作，直到剩下一整个连通块，最开始状态是每个点是一个单独的连通块。

复杂度是(n+m)longn，因为每次都会合并两个连通块，整个程序进行log次操作就会完成，每次操作的复杂度是n+m的。

代码非常好理解，我用的并查集实现，（然而并查集我没有用按秩合并，都是细节）。——by VANE

#include<bits/stdc++.h>
using namespace std;
const int N=;
const int M=;
int pre[M<<],other[M<<],last[N],l,len[M<<];
int n,m;
void add(int x,int y,int z)
{
    ++l;pre[l]=last[x];last[x]=l;other[l]=y;len[l]=z;
}
int f[N],mn[][N];
int getfa(int x)
{
    return x==f[x]?x:f[x]=getfa(f[x]);
}
void merge(int x,int y)
{
    int fx=getfa(x),fy=getfa(y);
    f[fx]=fy;
}
int main()
{
    scanf("%d%d",&n,&m);
    for(int i=;i<=n;++i) f[i]=i;
    for(int i=;i<=m;++i)
    {
        int x,y,z;
        scanf("%d%d%d",&x,&y,&z);
        add(x,y,z);add(y,x,z);
    }
    int ans=;
    while()
    {
        memset(mn[],,sizeof mn[]);
        bool flag=;
        for(int i=;i<=n;++i)
        {
            for(int p=last[i];p;p=pre[p])
            {
                if(getfa(i)!=getfa(other[p]))
                if(mn[][getfa(i)]>len[p])
                {
                    mn[][getfa(i)]=len[p];
                    mn[][getfa(i)]=getfa(other[p]);
                }
            }
        }
        for(int i=;i<=n;++i)
        {
            if(mn[][i]!=mn[][]&&getfa(i)!=getfa(mn[][i]))
            {
                flag=;
                ans+=mn[][i];
                merge(i,mn[][i]);
            }
        }
        if(!flag) break;
    }
    for(int i=;i<n;++i)
    if(getfa(i)!=getfa(i+))
    {
        puts("orz");
        return ;
    }
    cout<<ans;
}