MST prim kuskal

POJ 1258 最小生成树模版题
输入图的邻接矩阵，求最小生成树的总权值
(多组数据）
输入样例：
4
0 4 9 21
4 0 8 17
9 8 0 16
21 17 16 0
输出样例：
28
Prim算法
假设G=(V,E)是一个具有n个顶点的连通网，
T=(U,TE)是G的最小生成树，U,TE初值均为空集。
首先从V中任取一个顶点（假定取v1），将它并入
U中，此时U={v1}，然后只要U是V的真子集(U∈V)，
就从那些一个端点已在T中，另一个端点仍在T外
的所有边中，找一条最短边，设为(v i ,v j ),其中
v i ∈U,v j ∈V-U，并把该边(v i , v j )和顶点v j 分别并入T
的边集TE和顶点集U，如此进行下去，每次往生成
树里并入一个顶点和一条边，直到n-1次后得到最
小生成树。
Prim算法实现
• 图节点数目为N,正在构造的生成树为T,
• 维护Dist数组,Dist[i]表示Vi到T的“距离”
• 开始所有Dist[i] = 无穷大, T 为空集
1) 若|T| = N，最小生成树完成。否则取Dist[i]最小
的不在T中的点Vi, 将其加入T
2) 更新所有与Vi有边相连且不在T中的点Vj的Dist值：
Dist[j] = min(Dist[j],W(Vi,Vj))
3) 转到1）
关键问题
每次如何从连接T T 中和T T 外顶点的所有边中，找
到一条最短的
1) 如果用邻接矩阵存放图，而且选取最短边的
时候遍历所有点进行选取，则总时间复杂度为
O(V 2 ), V 为顶点个数
2)用邻接表存放图,并使用堆来选取最短边，则
总时间复杂度为O(ElogV)
不加堆优化的Prim 算法适用于密集图，加堆优
化的适用于稀疏图

#include <iostream>
#include <vector>
#include <queue>
#include <algorithm>
#include <cstdio>
using namespace std;
const int INF=1<<30;
struct edge
{
    int v;//边端点
    int w;//边权值，也表示v到在建最小生成树的距离
    edge(int v_=0,int w_=INF):v(v_),w(w_) { }
    bool operator <(const edge &e)const
    { return w>e.w;}//权值小的在去前
};
vector<vector <edge> >g(105);//类似于邻接表,一定要在后两个留空格
int prim(const vector<vector<edge> > &g,int n)
{//G是邻接表,n是顶点数目，返回值是最小生成树权值和
    int i,j,k;
    edge xdist(0,0);//
    priority_queue<edge> pq;//存放顶点及其到在建生成树的距离
    vector<int> vdist(n);//各顶点到已经建好的那部分树的距离
    vector<int> vused(n);//标记顶点是否已经被加入最小生成树
    int ndonenum=0;//已经被加入最小生成树的顶点数目
    for (int i=0;i<n;i++)
    {
        vused[i]=0;
        vdist[i]=INF;
    }
    ndonenum=0;
    int ntotalw=0;//最小生成树总权值
    pq.push(edge(0,0));//开始只有顶点0,它到最小生成树距离0
    while(ndonenum<n&&!pq.empty()){
    do{//每次从队列里面拿离在建生成树最近的点
    xdist=pq.top();
       pq.pop();
    }while(vused[xdist.v]==1&&!pq.empty());
    if(vused[xdist.v]==0)
    {
        ntotalw+=xdist.w;
        vused[xdist.v]=1;
        ndonenum++;
        for (i=0;i<g[xdist.v].size();i++)
        {//更新新加入点的邻点
            int k=g[xdist.v][i].v;
            if(vused[k]==0)
            {
                int w=g[xdist.v][i].w;
                    if (vdist[k]>w)
                    {
                        vdist[k]=w;
                        pq.push(edge(k,w));
                    }
            }
        }
    }
   }
    if(ndonenum<n)
        return -1;//图不连通
    return ntotalw;
}//考察了所有的边，且考察一条边时 可能执行 pq.push(Edge(k,w)) 故复杂度O(ELogV)
int main()
{
    int n;
    while(cin>>n)
    {
        for (int i=0;i<n;i++)
            g[i].clear();
        for (int i=0;i<n;i++)
        {
            for (int j=0;j<n;j++)
            {
                int w;
                cin>>w;
                g[i].push_back(edge(j,w));
            }
        }
        cout<<prim(g,n)<<endl;
    }
    return 0;
}

Kruskal算法
假设G=(V,E)是一个具有n个顶点的连通网，
T=(U,TE)是G的最小生成树，U=V,TE初值为
空。
将图G中的边按权值从小到大依次选取，若
选取的边使生成树不形成回路，则把它并
入TE中，若形成回路则将其舍弃，直到TE
中包含N-1条边为止，此时T为最小生成树。
关键问题
如何判断欲加入的一条边是否与生成树
中边构成回路。
将各顶点划分为所属集合的方法来解决，
每个集合的表示一个无回路的子集。开
始时边集为空，N个顶点分属N个集合，
每个集合只有一个顶点，表示顶点之间
互不连通。
当从边集中按顺序选取一条边时，若它
的两个端点分属于不同的集合，则表明
此边连通了两个不同的部分，因每个部
分连通无回路，故连通后仍不会产生回
路，此边保留，同时把相应两个集合合
并

#include <iostream>
#include <vector>
#include <algorithm>
#include <cstdio>
using namespace std;
struct edge
{
    int s,e,w;//起点，终点，权值
    edge(int ss,int ee,int ww):s(ss),e(ee),w(ww) { }
    edge(){}
    bool operator <(const edge&e1)const
    { return w<e1.w;}
};
vector<edge> edges;
vector<int> parent;
int getroot (int a)
{
    if(parent[a]==a)
        return a;
    parent[a]=getroot(parent[a]);
    return parent[a];
}
void merge(int a,int b)
{
    int p1=getroot(a);
    int p2=getroot(b);
    if(p1==p2)
        return ;
    parent[p2]=p1;
}
int main()
{
    int n;
    while(cin>>n)
    {
        parent.clear();
        edges.clear();
        for (int i=0;i<n;i++)
            parent.push_back(i);
        for (int i=0;i<n;i++)
        {
            for (int j=0;j<n;j++)
            {
                int w;
                cin>>w;
                edges.push_back(edge(i,j,w));
            }
        }
            sort(edges.begin(),edges.end());//排序复杂度O(ElogE
            int done=0;
            int totallen=0;
            for(int i=0;i<edges.size();i++){
            if(getroot(edges[i].s)!=getroot(edges[i].e))
            {
                merge(edges[i].s,edges[i].e);
                done++;
                totallen+=edges[i].w;
            }
            if (done==n-1) break;
            }
        cout<<totallen<<endl;
    }
}