关于最小生成树算法的理解

生成树：连通图中取出一个子图，包括所有的点且是一棵树。（任意两点之间一条路径）

最小生成树：一个连通图中边权之和最小的生成树

求最小生成树的算法主要有两个：

prim算法和kruskal算法，那么我们接下来分别来了解一下：

--------------------------------------------------prim算法------------------------------------------------------------------------

使用范围：连通图，不是连通图没有生成树可言

算法思想：

1.我们定义一个cost数组，记录的是某个点加入生成树点集的代价,初始化为INF。

2.因为点放入的先后顺序不影响最后结果，所以我们先随机选一个点u放入生成树点集，然后与点u相连的点v的边权可以更新cost，因为把某个集合外的点放入生成树集合S的代价就是与集合内一个点连一条边，初始集合内只有一个点，更新之后的代价中选择最小的加入集合。

3.然后加入新的点进入集合之后，重新更新cost重复执行2，然后直到S包含了点的全集，算法结束。

那么为什么每次选取最小的代价，最后生成树的代价之和就一定是最小的呢？

我们来考虑，当前我们得到了一棵生成树，如果存在一条边mp[i][j],那么任意点u!=i,mp[u][j] >= mp[i][j]，否则这棵生成树就不是最小的了。

那么重复这一步骤，便可以知道了每次选择当前代价最小的正确性

代码实现如下：

int prim ( )  
{  
    memset ( used , false , sizeof (used ) );  
    memset ( cost , 0x3f , sizeof ( cost ) );  
    int u = 1 , minn ,ret = 0;  
    for ( int i = 1 ; i < n ; i++ )  
    {  
        used[u] = true;  
        minn = cost[0];  
        for ( int j = head[u] ; ~j ; j = e[j].next )  
        {  
            int v = e[j].v;  
            if ( used[v] ) continue;  
            cost[v] = min ( cost[v] , e[j].w );  
            if ( cost[v] < minn )  
                minn = cost[v] , u = v;  
        }  
        ret += minn;  
    }  
    return ret;  
}  

复杂度O(n^2)

--------------------------------------------------kruskal算法-----------------------------------------------------------------------

算法思想：

kruskal的算法思想很简单，就是对并查集的简单应用，因为权值被边承载，所以先对边进行排序，利用并查集记录两个点是否已经连通，然后从前到后枚举边，如果边的两个点不连通，那么选取这条边，知道所有的点都连通为止，因为每棵树有n-1条边，所以这样得到的生成树一定是最小的。

证明方法与prim类似，逆向的考虑一下就明白了

下面是算法实现：

struct Edge  
{  
    int u,v,w;  
    bool operator < ( const Edge& a ) const   
    {  
        return w < a.w;  
    }  
}e[MAX*MAX];  
  
int cc = 0;  
  
void add ( int u , int v , int w )  
{  
    e[cc].u = u;  
    e[cc].v = v;  
    e[cc].w = w;  
    cc++;  
}  
  
int fa[MAX];  
  
void init ( )  
{  
    for ( int i = 1 ; i <= n ; i++ )  
        fa[i] =i;  
    cc = 0;  
}  
  
int find ( int x )  
{  
    return x==fa[x]?x:fa[x]=find(fa[x]);  
}  
  
void _union ( int x , int y )  
{  
    x = find (x);  
    y = find (y);  
    fa[x] = y;  
}  
  
int kruskal ( )  
{  
    sort ( e , e+cc );  
    int sum = 0;  
    for ( int i = 0 ; i < m ; i++ )  
    {  
        int u = find ( e[i].u );  
        int v = find ( e[i].v );  
        if ( u == v ) continue;  
        _union ( u , v );  
        sum += e[i].w;  
    }  
    int flag = find ( 1 );  
    for ( int i = 2 ; i <= n ; i ++ )  
        if ( find(i) != flag ) return -1;  
    return sum;  
}