kruskal

这只是运算过程，真正重要的是建图和结合题目的过程
关于kruskal就像某东说的一样，比较独立，非常简单，学完之后不需要在反复理解，做题时只要知道并且会打就行。

我们要最小生成树，就是找一个边集，通过这个边集，可以花费最少地遍历所有点。

kruskal是一个贪心的过程，按边权排完序，从小到大跑边，如果这条边的两个端点不连通，就把它们连起来（本来就是为了把所有点都连起来），如果已经连通那么说明之前这两个点已经在最小生成树里，其实过程有点玄学，多想想就好了。
这两个点的边，时间复杂度O(elogv),最慢的是sort,O(eloge)，并查集维护连通性是一个反阿克曼函数。

#include "stdafx.h"
#include<iostream>
#include<algorithm>
using namespace std;
const int MAXN = 23333333;
int fa[MAXN], noderank[MAXN];
void union_find_init(int v)
{
    for (int i = 1; i <= v; i++)
    {
        fa[i] = i;
        noderank[i] = 0;
    }
}
int find(int x)
{
    return x == fa[x] ? x : fa[x] = find(fa[x]);
}
void unite(int x, int y)
{
    x = find(x);
    y = find(y);
    if (x == y) return;
    if (noderank[x] < noderank[y]) fa[x] = y;
    else
    {
        fa[y] = x;
        if (noderank[x] == noderank[y]) noderank[x] ++;
    }
}
bool same(int x, int y)
{
    return find(x) == find(y);
}
struct edge
{
    int u;
    int v;
    int cost;
};
bool cmp(const edge& e1, const edge& e2)
{
    return e1.cost < e2.cost;
}
const int MAXN = 23333;
edge es[MAXN];
int v, e;
int kruskal()
{
    sort(es, es + e,cmp);
    union_find_init(v);
    int res = 0;
    for (int i = 0; i < e; i++)
    {
        edge e = es[i];
        if (!same(e.u, e.v))
        {
            unite(e.u, e.v);
            res += e.cost;
        }
    }
    return res;
}

听说过压行吗？还有，其实不用按秩合并

#include<iostream>
#include<algorithm>
using namespace std;
const int MAXN = 233333;
int fa[MAXN],ans = 0,e;//边的数量 
void init(int v) {for(int i = 1;i <= v;i ++) fa[i] = i};
int find(int x) {return x == fa[x] ? x : fa[x] = find(fa[x]);}
bool same(int x,int y) {return find(x) == find(y);}
void unite(int x,int y) {if(!same(x,y)) fa[x] = y;}
struct edge{int u,v,cost} es[MAXN];
bool cmp(edge e1,edge e2){return e1.cost < e2.cost;}
int kruskal()
{
    sort(es + 1,es + MAXN + 1,cmp);
    init(MAXN);
    for(int i = 0;i < e;i ++) if(!same(e.u,e.v)) {unitr(e.u,e.v);ans += e.cost;}
    return ans;
}