最小生成树（Prim，Kurskal）

 1)最小生成树的Prim算法 伪码实现：

/**
    1)最小生成树的Prim算法 伪码实现：

    Prim(G,d[])
    {
        初始化;
        for(循环n次)
        {
            u=使d[u]最小的还未被访问的顶点的标号;
            记u已被访问;
            for(从u出发能到达的所有顶点v)
            {
                if(v未被访问 && 以u为中介点使得v与集合S得最短距离d[v]更优)
                {
                    将G[u][v]赋值给v与集合S的最短距离d[v];
                }
            }
        }
    }
*/

 2) 最小生成树的Prim算法,邻接矩阵：

/**
    2)
    最小生成树的Prim算法,邻接矩阵：
    const int maxn = 1010;
    const int INF = 0x3fffffff;
    int G[amxn][maxn];
    int d[maxn];
    bool hs[maxn];

    int Nv,Ne;

    int Prim()
    {
         fill(d,d+maxn,INF);
         d[0]=0;
         int ans=0;
         for(int i=0;i<Nv;++i)
         {
            int u=-1,MIN=INF;
            for(int j=0;j<Nv;++j)
                if(hs[j]==0 && d[j]<MIN)
                {
                    u=j;
                    MIN=d[j];
                }

             if(u==-1)
                return -1;
            hs[u]=1;
            ans+=d[u];
            for(int v=0;v<Nv;++v)
            {
                if(hs[v]==0 && G[u][v]!=INF && G[u][v]<d[v])
                    d[v]=G[u][v];
            }
         }

         return ans;
    }
*/

3)最小生成树的Prim算法,邻接表：

/**
    3)最小生成树的Prim算法,邻接表：
    const int maxn = 1010;
    cosnt int INF = 0x3fffffff;

    struct GNode
    {
        int v,dis;
    };
    vector<GNode> Adj[maxn];
    int d[maxn];
    bool hs[maxn];

    int Nv,Ne;

    int Prim()
    {
        fill(d,d+maxn,INF);
        d[0]=0;
        int ans=0;
        for(int i=0;i<Nv;++i)
        {
            int u=-1,MIN=INF;
            for(int j=0;j<Nv;++j)
                if(d[j]<MIN)
                {
                    u=j;
                    MIN=d[j];
                }

            if(u==-1)
                return -1;
            hs[u]=1;
            ans+=d[u];
            for(int k=0;k<Adj[u].size();++k)
            {
                int v=Adj[u][k].v;
                if(hs[v]==0 && Adj[u][v].dis<d[v])
                    d[v]=Adj[u][v].dis;
            }
        }

        return ans;
    }
*/

最小生成树Kruskal 算法：伪码实现：

/**
    最小生成树Kruskal 算法：伪码实现：

    struct ENode
    {
        int u,v;
        int cost;
    };

    bool cmp(ENode a,ENode b)
    {
        return a.cost < b.cost;
    }

    int Kruskal()
    {
        令最小生成树的边权之和为ans，令最小生成树的当前边数之和为Num_Edge;
        将所有边按边权从小到大开始排序；
        for(从小到大枚举所有边)
        {
            if(当前测试边的两个顶点在不同的连通块中)
            {
                将该测试边加入到最小生成树中;
                ans+= 测试边的边权;
                最小生成树的边数 Num_Edge 加1；
                当边数Num_Edge 等于顶点数减一时结束循环;
            }
        }
        return ans;
    }
*/

代码解释：

/**
    const int maxn = 1010;
    int fath[maxn];

    struct ENode
    {
        int u,v;
        int cost;
    };
    ENode E[maxn];

    int Nv,Ne;

    int FindFather(int x)
    {
        if(fath[x]<0)
            return x;
        else
            return fath[x] = FindFather(fath[x]);
    }

    int Kruskal()
    {
        int ans=0,Num_Edge=0;
        memeset(fath,-1,sizeof(fath));
        sort(E,E+Ne,cmp);
        for(int i=0;i<Ne;++i)
        {
            int faU = FindFather(E[i].u);
            int faV = FindFather(E[i].v);
            if(faU!=faV)
            {
                fath[faU]=faV;
                Num_Edge++;
                ans+=E[i].cost;
                if(Num_Edge == Nv-1)
                    break;
            }
        }
        if(Num_Edge != Nv-1)
            return -1;
        return ans;
    }
*/