最小生成树（prim）

里姆算法（Prim算法），图论中的一种算法，可在加权连通图里搜索最小生成树。意即由此算法搜索到的边子集所构成的树中，不但包括了连通图里的所有顶点（英语：Vertex (graph theory)），且其所有边的权值之和亦为最小。

介绍如下：

http://baike.baidu.com/link?url=nDhHyOlu8i90Hm5bjUycarVdBPN8BXQvnv8NGwl0g4MLlLkmkFLwf7xs1-JBWCRkQw5qDU6cIwh1ov7fyRRxQK

原理可以参考这几篇文章：

http://www.cnblogs.com/biyeymyhjob/archive/2012/07/30/2615542.html

http://blog.csdn.net/weinierbian/article/details/8059129

http://blog.chinaunix.net/uid-25324849-id-2182922.html

prim算法适合稠密图，邻接矩阵时间复杂度为O(n^2)，邻接表为O(eloge)，其时间复杂度与边得数目无关。

而kruskal算法的时间复杂度为O(eloge)跟边的数目有关，适合稀疏图。

邻接矩阵实现：

#include <iostream>
using namespace std;

#define MAXVEX 20
#define MAXEDGE 20
#define INFINITY 65535



typedef struct
{
          int vexs[MAXVEX];
          int arc[MAXVEX][MAXVEX];
          int numVertexes,numEdges;
}MGraph;

typedef int Patharc[MAXVEX];
typedef int ShortPathTable[MAXVEX];

bool visited[MAXVEX];//保存已访问的数组
int father[MAXVEX];
int closeset[MAXVEX];

void CreateGraph(MGraph* G)
{
          cout<<"请输入边数和顶点数:
";
          int d,n,i,j;
          cin>>d>>n;
          G->numVertexes = n;
          G->numEdges = d;

          //给顶点和边初始化
          for(i = 0;i<G->numVertexes;i++)
                    G->vexs[i] = i;
          for(i = 0;i<G->numVertexes;i++)
          {
                    for(j = 0;j<G->numVertexes;j++)
                    {
                              if(i==j)
                                        G->arc[i][j] = 0;
                              else
                                        G->arc[i][j] = G->arc[j][i] = INFINITY;
                    }
          }

          G->arc[0][1]=1;
          G->arc[0][2]=5;
          G->arc[1][2]=3;
          G->arc[1][3]=7;
          G->arc[1][4]=5;

          G->arc[2][4]=1;
          G->arc[2][5]=7;
          G->arc[3][4]=2;
          G->arc[3][6]=3;
          G->arc[4][5]=3;

          G->arc[4][6]=6;
          G->arc[4][7]=9;
          G->arc[5][7]=5;
          G->arc[6][7]=2;
          G->arc[6][8]=7;

          G->arc[7][8]=4;

          for(i = 0;i<G->numVertexes;i++)
          {
                    for(j = i;j<G->numVertexes;j++)
                    {
                              G->arc[j][i] = G->arc[i][j];
                    }
          }
}


int prim(MGraph G, Patharc *P, ShortPathTable *D)
{
          int v,w;

          //init
          for(v = 0;v<G.numVertexes;v++)
          {
                    visited[v] = false;
                    (*D)[v] = G.arc[0][v];
                    father[v] = -1;
                    closeset[v] = 0;
          }
          visited[0] = true;

          int len = 0;
          int nlen,nid;

          //求得下一个符合条件的点
          for(v = 1;v<G.numVertexes;v++)
          {
                   nlen = INFINITY;
                   for(w = 0;w<G.numVertexes;w++)
                   {
                             if(!visited[w] && (*D)[w]<nlen)
                             {
                                       nlen = (*D)[w];
                                       nid = w;
                             }
                   }

                   len += nlen;
                   visited[nid] = true;
                   father[nid] = closeset[nid];

                   for(w = 0;w<G.numVertexes;w++)
                   {
                             if(!visited[w] && (*D)[w]>G.arc[nid][w])
                             {
                                       (*D)[w] = G.arc[nid][w];
                                       closeset[w] = nid;
                             }
                   }


          }

          return len;

}


int main()
{
          int v0,i,j;

          MGraph G;

          Patharc P;
          ShortPathTable D;

          CreateGraph(&G);

          int d = prim(G,&P,&D);

          cout<<"最小树如下:
";
          for(i = 1;i<G.numVertexes;i++)
          {
                   cout<<"("<<i<<","<<father[i]<<") ";
          }
          cout<<endl;

          cout<<"最短路径长度为:
";

          cout<<d<<endl;

          return 0;


}

我是用vector和pair的邻接表实现的，然后用两个list保存两个集合，一个最小生成树集，一个其他集

实现如下：

#include <iostream>
#include <vector>
#include <queue>
#include <list>
using namespace std;

vector<pair<int,int> > eg[100];

vector<pair<int,int> > result;

typedef pair<int,int> pa;

bool visit[100];

list<int> setOfPrim;

list<int> outOfPrim;

int lowcost[100] = {0};

void prim(int n,int d)
{
          int min,aim,sta;
          bool is;

          list<int>::iterator sop;//最小树集合
          list<int>::iterator oop;//其他集合
          vector<pair<int,int> >::iterator it;

          setOfPrim.push_back(0);//放入起始点0进最小树集合

          //初始化其他集合
          for(int i = 1;i<n;i++)
                   outOfPrim.push_back(i);

          while(!outOfPrim.empty())//其他集合不为空
          {
                    //遍历最小树集合，sop，寻找与集合最近的点
                    min = 1<<16;
                    for(sop = setOfPrim.begin();sop!=setOfPrim.end();sop++)
                    {
                              //遍历sop邻接点
                              for(int i = 0;i<eg[*sop].size();i++)
                              {
                                        pa x = eg[*sop][i];
                                        is = false;

                                        //如果点属于oop集合
                                        for(oop = outOfPrim.begin();oop!=outOfPrim.end();oop++)
                                        {
                                                  if(*oop == x.first)
                                                  {
                                                            is = true;
                                                  }
                                        }

                                        if(is)
                                        {
                                                  if(x.second<min)
                                                  {
                                                            min = x.second;
                                                            aim = x.first;
                                                            sta = *sop;
                                                  }
                                                  //min存放了离sop集合最近的点的距离
                                                  //aim存放了点的序号
                                        }
                              }
                    }

                    setOfPrim.push_back(aim);
                    result.push_back(make_pair(sta,aim));
                    for(oop = outOfPrim.begin(); oop != outOfPrim.end(); )
                    {
                              if(*oop == aim)
                              {
                                        oop = outOfPrim.erase(oop);
                                        if(outOfPrim.empty())
                                                  break;
                              }
                              else
                                        oop++;
                    }
                    cout<<"The set of prim:
";
                    for(sop = setOfPrim.begin(); sop != setOfPrim.end();sop++)
                    {
                              cout<<*sop<<" ";
                    }
                    cout<<"
The set of not prim:
";
                    for(oop = outOfPrim.begin(); oop != outOfPrim.end();oop++)
                    {
                              cout<<*oop<<" ";
                    }
                    cout<<endl;

                    for(it = result.begin();it!=result.end();it++)
                    {

                              cout<<"("<<(*it).first<<","<<(*it).second<<")";
                    }
                    cout<<endl<<endl;
          }
}


int main()
{
          int n,d;
          cin>>n>>d;
          for(int i = 0;i<d;i++)
          {
                    int t,s,w;
                    cin>>t>>s>>w;
                    eg[t].push_back(make_pair(s,w));
                    eg[s].push_back(make_pair(t,w));
          }
          prim(n,d);



}
/*
6 8
0 1 2
0 3 4
1 4 4
2 0 5
2 5 2
3 4 3
3 5 7
5 4 3
*/

另外，因为prim算法和Dijkstra算法很像，这篇文章有讲两者之间的区别：

http://www.cnblogs.com/CheeseZH/archive/2012/10/09/2717106.html