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;
}