最小生成树kruskal

离散里学过原理了，就是避圈法，将边排序，不断选取最小的，并且不能形成圈（这个就是用并查集来判断）直至全部选完。

自己手写了个代码，差不多就是白书上的，没有检查正确性

const int maxn = 100000 + 5;
const int inf = 0x3f3f3f3f;
int rank[maxn];
int fa[maxn];
int V;//顶点数
void init()
{
    for(int i=0; i<V; i++)
    {
        fa[i] = i;
        rank[i] = 0;
    }
}
int find(int x)
{
    if(fa[x] == x)
        return fa[x];
    else return fa[x] = find(fa[x]);
}

bool same(int x, int y)
{
    x = find(x);
    y = find(y);
    if(x == y) return true;
    return false;
}

void unite(int x, int y)
{
    x = find(x);
    y = find(y);
    if(x == y) return;
    if(rank[x] < rank[y])
        fa[x] = y;
    else
    {
        fa[y] = x;
        if(rank[x] == rank[y]) rank[x]++;
    }
    return;
}

struct edge
{
    int u;
    int v;
    int cost;
};
edge bian[maxn];
int V,E;//边数和顶点数

bool cmp(edge p ,edge q)
{
    return p.cost < q.cost;
}

int kruskal()
{
    sort(bian,bian,cmp);
    init(V);//并查集初始化
    int ans = 0;
    for(int i=0; i<E; i++)
    {
        edge sam = bian[i];
        if(!same(sam.v,sam.u))
        {
            unite(sam.v,sam.u);
            ans += sam.cost;
        }
    }
    return ans;
}