用Kruskal和Prim算法求最小生成树
原理不多说，直接上代码。
代码一，Kruskal算法实现：
/*
参考自http://blog.csdn.net/niushuai666/article/details/6689285 有增删。
克鲁斯卡尔（Kruskal）算法（只与边相关）
算法描述：克鲁斯卡尔算法需要对图的边进行访问，所以克鲁斯卡尔算法的时间复杂度只和边有关系，可以证明其时间复杂度为O（eloge）。
算法过程：
1.将图各边按照权值进行排序
2.将图遍历一次，找出权值最小的边，（条件：此次找出的边不能和已加入最小生成树集合的边构成环），若符合条件，则加入最小生成树的集合中。不符合条件则继续遍历图，寻找下一个最小权值的边。
3.递归重复步骤1，直到找出n-1条边为止（设图有n个结点，则最小生成树的边数应为n-1条），算法结束。得到的就是此图的最小生成树。
克鲁斯卡尔（Kruskal）算法因为只与边相关，则适合求稀疏图的最小生成树。而prime算法因为只与顶点有关，所以适合求稠密图的最小生成树。
*/
#include <iostream>
#include <algorithm>
using namespace std;
#define SMALL_CASE // 只应用于26个字符的数据输入，输入节点按a~z编号。
//#define BIG_CASE // 超过应用于26个字符的数据输入，输入节点按1 2 3编号。
#ifdef SMALL_CASE
#define MAX 26
#define NODETYPE char
#elif BIG_CASE
#define MAX 1000
#define NODETYPE int
#endif
int father[MAX], son[MAX]; // father的值表示当前点所属连通分支的首结点索引 son表示以当前点为首结点的子结点数
int nodeCount, edgeCount;
struct Kruskal //存储边的信息
{
int a;
int b;
int value;
};
// 比较两条边的权值
bool cmp(const Kruskal &a, const Kruskal &b)
{
return a.value < b.value;
}
// 假设选中某边后，检查该边的一结点x是否原先已经在该连通分支中，如果在，返回该连通分支中第一条边的首结点。否则返回默认首结点。
int unionsearch(int x) //查找根结点+路径压缩
{
return x == father[x] ? x : unionsearch(father[x]);
}
// 测试某边是否可以加入到当前树中来，并不构成圈
bool join(int x, int y)
{
int root1, root2;
root1 = unionsearch(x);
root2 = unionsearch(y);
if(root1 == root2) //为圈
{
return false;
}
// 如果不构成圈，那么这条边将被选中，这里更新father、son的值
else if(son[root1] >= son[root2])
{
father[root2] = root1;
son[root1] += son[root2];
}
else
{
father[root1] = root2;
son[root2] += son[root1];
}
return true;
}
int main()
{
int eCount/*已选择的边数*/, sum/*权值总和*/, flag/*求得最小生成树标志*/;
Kruskal edge[MAX]; // 边集
// 基本输入
cout << "输入点数和边数：";
cin >> nodeCount >> edgeCount;
eCount = 0, sum = 0, flag = 0;
for(int i = 1; i <= nodeCount; ++i) //初始化
{
father[i] = i;
son[i] = 1;
}
#ifdef SMALL_CASE
cout << "输入每条边的连接信息（端点a 端点b 权值）：" << endl;
NODETYPE va, vb;
#elif BIG_CASE
cout << "输入每条边的连接信息（端点1 端点2 权值）：" << endl;
#endif
// 将边信息和权值换算成相应整数
for(int i = 1; i <= edgeCount ; ++i)
{
#ifdef SMALL_CASE
cin >> va >> vb >> edge[i].value;
edge[i].a = va - 'a', edge[i].b = vb - 'a';
#elif BIG_CASE
cin >> edge[i].a >> edge[i].b >> edge[i].value;
#endif
}
// 不断选择边，求最小生成树
sort(edge + 1, edge + 1 + edgeCount, cmp); //按权值由小到大排序
for(int i = 1; i <= edgeCount; ++i)
{
if(join(edge[i].a, edge[i].b)) //看此边是否加选择
{
eCount++; //边数加1
sum += edge[i].value; //记录权值之和
#ifdef SMALL_CASE
cout << (char)(edge[i].a + 'a') << "->" << (char)(edge[i].b + 'a') << endl;
#elif BIG_CASE
cout << edge[i].a << "->" << edge[i].b << endl;
#endif
}
if(eCount == nodeCount - 1) //最小生成树条件：边数=顶点数-1
{
flag = 1;
break;
}
}
if(flag) // 是否生成了最小生成树
{
cout << "权值和：" << sum << endl;
}
else
{
cout << "data error." << endl;
}
return 0;
}
代码二，Prim算法实现：
/*
参考自http://blog.csdn.net/niushuai666/article/details/6689285 有删减。
普利姆（Prime）算法（只与顶点相关）
算法描述：
普利姆算法求最小生成树时候，和边数无关，只和定点的数量相关，所以适合求稠密网的最小生成树，时间复杂度为O（n*n）。
算法过程：
1.将一个图的顶点分为两部分，一部分是最小生成树中的结点（A集合），另一部分是未处理的结点（B集合）。
2.首先选择一个结点，将这个结点加入A中，然后，对集合A中的顶点遍历，找出A中顶点关联的边权值最小的那个（设为v），将此顶点从B中删除，加入集合A中。
3.递归重复步骤2，直到B集合中的结点为空，结束此过程。
4.A集合中的结点就是由Prime算法得到的最小生成树的结点，依照步骤2的结点连接这些顶点，得到的就是这个图的最小生成树。
*/
#include <limits.h>
#include <iostream>
#include <cstring>
using namespace std;
#define INF 1000 // 边取值的最大值
#define SMALL_CASE
#ifdef SMALL_CASE // 输入对应a~z编号
#define MAXN 26
#elif BIG_CASE // 输入对应从1开始编号
#define MAXN 1000
#endif
int map[MAXN][MAXN], lowcost[MAXN]; // map图的点权值图，lowcost到某点i的最小花销，也就是与点i相连的边中的最小边
bool visit[MAXN]; // 点是否选中
int nodenum, sum; // 结点数 权值和
void prim()
{
int minWeight, k; // 与某点k相连的最小边
sum = 0;
fill_n(visit, MAXN, false);
visit[0] = true;
for(int i = 0; i < nodenum; ++i) //初始化lowcost[i]
{
lowcost[i] = map[0][i];
}
int otherNode; // 与新加入点以最小边相连的另一点
for(int i = 0; i < nodenum; ++i) //找生成树集合点集相连最小权值的边
{
// 找出已选点与未选点之间相连的最小边
minWeight = INF;
for(int j = 0; j < nodenum; ++j)
{
if(!visit[j] && minWeight > lowcost[j])
{
minWeight = lowcost[k = j]; // 注意k会在这里变化
}
}
if(minWeight == INF) // 在数据正常的情况下，这里minWeight的值为INF的情况是刚好生成最小生成树。
{
break;
}
visit[k] = true; //加入最小生成树集合
// 找到与k点相连的另一点
for(int j = 0; j < nodenum; j++)
{
if(map[j][k] == minWeight)
{
otherNode = j;
break;
}
}
#ifdef SMALL_CASE
cout << (char)(otherNode + 'a') << "-->" << (char)(k + 'a') << endl;
#elif BIG_CASE
cout << otherNode << "-->" << k << endl;
#endif
sum += minWeight; //记录权值之和
// 更新lowcost数组：因为新加入点k，使得集合间的最小花销发生了变化
for(int j = 0; j < nodenum; ++j)
{
if(!visit[j] && lowcost[j] > map[k][j]) // 从本循环中i点到j点的花销大于从k点到j点的花销
{
lowcost[j] = map[k][j];
}
}
}
}
int main()
{
int edgenum;
cout << "输入结点数和边数：";
cin >> nodenum >> edgenum;
if(nodenum > 0 && edgenum > 0 && edgenum <= (nodenum * (nodenum - 1) / 2))
{
fill_n((int*)map, MAXN * MAXN, INF); // 注意二维数组这里不要用memset函数哟
cout << "输入每条边的连接信息（端点a 端点b 权值）：" << endl;
int a, b, cost;
for(int i = 0; i < edgenum; ++i) //输入边的信息
{
#ifdef SMALL_CASE
char ca, cb;
cin >> ca >> cb >> cost;
a = ca - 'a', b = cb - 'a';
#elif BIG_CASE
cin >> a >> b >> cost;
#endif
if(cost < map[a][b])
{
map[a][b] = map[b][a] = cost;
}
}
prim();
cout << sum << endl; //最小生成树权值之和
}
else
{
cout << "data error." << endl;
}
return 0;
}