Boruvka算法求最小生成树

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

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

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

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

#include<bits/stdc++.h>
using namespace std;
const int N=5005;
const int M=200005;
int pre[M<<1],other[M<<1],last[N],l,len[M<<1];
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[2][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=1;i<=n;++i) f[i]=i;
    for(int i=1;i<=m;++i)
    {
        int x,y,z;
        scanf("%d%d%d",&x,&y,&z);
        add(x,y,z);add(y,x,z);
    }
    int ans=0;
    while(1)
    {
        memset(mn[0],127,sizeof mn[0]);
        bool flag=0;
        for(int i=1;i<=n;++i)
        {
            for(int p=last[i];p;p=pre[p])
            {
                if(getfa(i)!=getfa(other[p]))
                if(mn[0][getfa(i)]>len[p])
                {
                    mn[0][getfa(i)]=len[p];
                    mn[1][getfa(i)]=getfa(other[p]);
                }
            }
        }
        for(int i=1;i<=n;++i)
        {
            if(mn[0][i]!=mn[0][0]&&getfa(i)!=getfa(mn[1][i]))
            {
                flag=1;
                ans+=mn[0][i];
                merge(i,mn[1][i]);
            }
        }
        if(!flag) break;
    }
    for(int i=1;i<n;++i)
    if(getfa(i)!=getfa(i+1))
    {
        puts("orz");
        return 0;
    }
    cout<<ans;
}