最小生成树求法 Prim + Kruskal

prim算法的思路 和dijkstra是一样的

每次选取一个最近的点 然后去向新的节点扩张 注意这里的扩张 不再是 以前求最短路时候的到新的节点的最短距离

而是因为要生成一棵树 所以是要连一根最短的连枝 所以关键部分修改一下

dist[u] = min(dist[u], e.cost) --->>e是连接 v 和 u的边

同样地 普同写法O(v^2) 用队列优化后O(E*logV)

 #include <iostream>
 #include <stdio.h>
 #include <string.h>
 #include <queue>
 #define MAXV 256
 #define MAXE 256
 #define INF 0x3f3f3f3f

 using namespace std;
 typedef pair<int,int> P;
 int V, E;
 //和dijkstra完全一样
 //书上写法 O(V^2)
 int graph[MAXV][MAXV];
 int prim()
 {
     int dist[MAXV];
     int res = ;
     bool use[MAXV];
     fill(dist, dist+MAXV, INF);
     fill(use, use+MAXV, );
     dist[] = ;//假定1为源点
     while (true)
     {
         int v = -;
         for (int i = ; i <= V; i++)
         {
             if (!use[i] && (v == - || dist[i] < dist[v])) v = i;//查找离原点最近的点
         }
         if (v == -) break;
         use[v] = true;
         res += dist[v];
         cout << dist[v] << endl; //打印树枝的情况
         for (int i = ; i <= V; i++)
         {
             dist[i] = min(dist[i], graph[v][i]);//这里是唯一的区别  --->>.但其实 这个dist中的值 最后是有问题的 这样最后dist保存的 是离它最近的一个节点的边的值
             //第33行打印的结果之所以正确是因为 按着离原点最近的顺序 向外扩张 在dist改变之前已经打印了 但是打印之后它的值是可能会发生改变的
             /*
             3).重复下列操作，直到Vnew = V：

 a.在集合E中选取权值最小的边<u, v>，其中u为集合Vnew中的元素，
 而v不在Vnew集合当中，并且v∈V（如果存在有多条满足前述条件即具有相同权值的边，则可任意选取其中之一）；

 b.将v加入集合Vnew中，将<u, v>边加入集合Enew中；
             */
         }
     }
     return res;
 }

 //使用堆维护 再使用prim O(E*logV)
 struct Edge
 {
     int to, cost, next;
     Edge() {}
     Edge(int to, int cost, int next) : to(to), cost(cost), next(next) {}
 }edge[MAXE];
 int num = ;
 int head[MAXV];
 void Add(int from, int to, int cost)
 {
     edge[num] = Edge(to, cost, head[from]);
     head[from] = num++;
 }

 int prim2()
 {
     int dist[MAXV], res = ;
     bool use[MAXV];
     fill(use, use+MAXV, false);
     fill(dist, dist+MAXV, INF);
     priority_queue<P, vector<P>, greater<P> > que;
     dist[] = ;//假定1为源点
     que.push(P(dist[], ));//first -->距离 second -->编号
     while(!que.empty())
     {
         P p = que.top();
         que.pop();
         if (!use[p.second])//这个也是那个问题 先前点(作为现在去扩张的点 如果被打印过 就不再去打印它了 总之算法思路就是 从原点开始 让最近的一个点去扩张)
         {
             res += dist[p.second];
             cout << dist[p.second] << endl;
         }
         use[p.second] = true;
         if (dist[p.second] < p.first)
         {
             continue;
         }
         int t = head[p.second];
         while (t != -)
         {
             Edge e = edge[t];
             if (!use[e.to] && dist[e.to] > e.cost)
             {
                 dist[e.to] = e.cost;
                 que.push(P(e.cost, e.to));
             }
             t = e.next;
         }
     }
     return res;
 }

 int main()
 {
     freopen("in.txt", "r", stdin);
     scanf("%d%d", &V, &E);
     memset(edge, -, sizeof(edge));
     memset(head, -, sizeof(head));
     for(int i = ; i <= V; i++)
         for (int j = ; j <= V; j++) graph[i][j] = INF;
     for (int i = ; i < E; i++)
     {
         int from, to, cost;
         scanf("%d%d%d", &from, &to, &cost);
         graph[from][to] = cost;
         graph[to][from] = cost;
         Add(from, to, cost);
         Add(to, from, cost);
     }
     int ans = prim2();
     cout << ans << endl;
 }

Kruskal -->> O(E*logV)  思路就更加的简单

将所有的边 排序

贪心地从小到大取 如果连接进一个新的点 就加入树枝的集合中 最终 得到的边的集合就是最小生成树

这里判断是否是新的节点 就是判断连通性 那么就使用并查集非常容易

 #include <iostream>
 #include <stdio.h>
 #include <string.h>
 #include <algorithm>
 #define MAXV 256
 #define MAXE 256
 #define INF 0x3f3f3f3f
 using namespace std;

 int E, V;
 //Kruskal 思路: 按边的角度出发 将边从小到大排序 如果 from to 不再一个连通块中 就可以取这一条边(不会产生环)
 struct Edge
 {
     int from, to, cost;
     Edge(){}
     Edge(int from, int to, int cost) : from(from), to(to), cost(cost) {}
 }edge[MAXE];

 int par[MAXV];
 int find(int x)
 {
     if(x == par[x]) return x;
     else return par[x] = find(par[x]);
 }
 void unite(int x, int y)
 {
     int px = find(x), py = find(y);
     if (px == py) return ;
     else par[py] = px;
 }
 bool same(int x, int y)
 {
     int px = find(x), py = find(y);
     return px == py;
 }

 bool cmp(Edge e1, Edge e2)
 {
     return e1.cost < e2.cost;
 }

 //O(E*logV) -->>对于并查集的操作是logN
 int Kruskal()
 {
     int res = ;
     for (int i = ; i <= V; i++) par[i] = i;
     sort(edge, edge+E, cmp);
     for (int i = ; i < E; i++)
     {
         Edge e = edge[i];
         if (!same(e.from, e.to))
         {
             cout << e.from << " " << e.to << " : " << e.cost << endl;
             res += e.cost;
             unite(e.from, e.to);
         }
     }
     return res;
 }

 int main()
 {
     freopen("in.txt", "r", stdin);
     scanf("%d%d", &V, &E);
     for (int i = ; i < E; i++)
     {
         int from, to, cost;
         scanf("%d%d%d", &from, &to, &cost);
         edge[i] = Edge(from, to, cost);
     }
     int ans = Kruskal();
     cout << ans << endl;
     return ;
 }

转一篇写的很详细的博客

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