最小生成树（Prim算法）

最小生成树（Kruskal和Prim算法）

关于图的几个概念定义：

• 连通图：在无向图中，若任意两个顶点vi与vj都有路径相通，则称该无向图为连通图。
• 强连通图：在有向图中，若任意两个顶点vi与vj都有路径相通，则称该有向图为强连通图。
• 连通网：在连通图中，若图的边具有一定的意义，每一条边都对应着一个数，称为权；权代表着连接连个顶点的代价，称这种连通图叫做连通网。
• 生成树：一个连通图的生成树是指一个连通子图，它含有图中全部n个顶点，但只有足以构成一棵树的n-1条边。一颗有n个顶点的生成树有且仅有n-1条边，如果生成树中再添加一条边，则必定成环。
• 最小生成树：在连通网的所有生成树中，所有边的代价和最小的生成树，称为最小生成树。 
  

---

下面介绍两种求最小生成树算法 Kruskal在另一篇博客。

2.Prim算法

此算法可以称为“加点法”，每次迭代选择代价最小的边对应的点，加入到最小生成树中。算法从某一个顶点s开始，逐渐长大覆盖整个连通网的所有顶点。

1. 设图G顶点集合为U，首先任意选择图G中的一点作为起始点a，将该点加入集合V。
2. 再从集合U-V中找到另一点b使得点b到V中任意一点的权值最小，此时将b点也加入集合V；
3. 以此类推，现在的集合V={a，b}，再从集合U-V中找到另一点c使得点c到V中任意一点的权值最小，此时将c点加入集合V，直至所有顶点全部被加入V，此时就构建出了一颗MST（Minimum Spanning Tree，最小生成树）。
4. 因为有N个顶点，所以该MST就有N-1条边，每一次向集合V中加入一个点，就意味着找到一条MST的边。

  

解题思路：

1. 建立两个数组：lowcost[i]:表示以i为终点的边的最小权值,当lowcost[i]=0说明以i为终点的边的最小权值=0,也就是表示i点加入了MST；adjvex[i]:表示保存相关顶点的下标，例如｛0,0,1,2,3,0｝代表下标为0的数组没有联系，下标2的v2与下标1的v1有联系，下标3的v3与下标为2的v2有联系

2. 假设V1是起始点，进行初始化（∞代表无限大，即无通路）                                                                                     lowcost[2]=6，lowcost[3]=1，lowcost[4]=5，lowcost[5]=∞，lowcost[6]=∞，                                                                   mst[2]=1，mst[3]=1，mst[4]=1，mst[5]=1，mst[6]=1，（所有点默认起点是V1）

3. 明显看出，以V3为终点的边的权值最小=1，把v3加入集合v中即v={1,3}                                                                                因为点V3的加入，需要更新lowcost数组和mst数组：                                                                                                lowcost[2]=5，lowcost[3]=0，lowcost[4]=5，lowcost[5]=6，lowcost[6]=4                                                                      mst[2]=3，mst[3]=0，mst[4]=1，mst[5]=3，mst[6]=3

4. 明显看出，以V6为终点的边的权值最小=4，把v6加入集合v中即v={1,3，6}                                                                         因为点V6的加入，需要更新lowcost数组和mst数组：                                                                                                      lowcost[2]=5，lowcost[3]=0，lowcost[4]=2，lowcost[5]=6，lowcost[6]=0                                                                    mst[2]=3，mst[3]=0，mst[4]=6，mst[5]=3，mst[6]=0

5. 明显看出，以V4为终点的边的权值最小=2，把v4加入集合v中即v={1,3，6，4}                                                                    因为点V4的加入，需要更新lowcost数组和mst数组： 

   lowcost[2]=5，lowcost[3]=0，lowcost[4]=0，lowcost[5]=6，lowcost[6]=0

   mst[2]=3，mst[3]=0，mst[4]=0，mst[5]=3，mst[6]=0

6. 明显看出，以V2为终点的边的权值最小=5，把v2加入集合v中即v={1,3，6，4，2}                                                                因为点V2的加入，需要更新lowcost数组和mst数组：

   lowcost[2]=0，lowcost[3]=0，lowcost[4]=0，lowcost[5]=3，lowcost[6]=0

   mst[2]=0，mst[3]=0，mst[4]=0，mst[5]=2，mst[6]=0

7. 明显看出，以V5为终点的边的权值最小=3，把v5加入集合v中即v={1,3，6，4，2，5}                                                          因为点V5的加入，需要更新lowcost数组和mst数组：

   lowcost[2]=0，lowcost[3]=0，lowcost[4]=0，lowcost[5]=0，lowcost[6]=0

   mst[2]=0，mst[3]=0，mst[4]=0，mst[5]=0，mst[6]=0

8. 至此，MST构建成功

---

3.完整代码

运行结果：

#include<iostream>
using  namespace std;

#define MAX 100
#define MAXCOST 0x7fffffff

int graph[MAX][MAX];

int prim(int graph[][MAX], int n)
{
	int lowcost[MAX];//保存相关顶点之间的权值
	int adjvex[MAX];//保存相关顶点的下标
	int i, j, min, minid, sum = 0;
	adjvex[1] = 0;//初始化第一个权值为0，即v0已经加入最小生成树
	//lowcost的值为0，在这里就是此下标的顶点已经加入最小生成树
	for (i = 2; i <= n; i++)
	{
		lowcost[i] = graph[1][i];//将v1顶点与其他边的权值存入数组lowcost
		adjvex[i] = 1;//初始化都为v1的下标
	}
	for (i = 2; i <= n; i++)
	{
		min = MAXCOST;//初始化最小权值为无穷
		minid = 0;
		for (j = 2; j <= n; j++)
		{
			if (lowcost[j] < min && lowcost[j] != 0)
			{
				min = lowcost[j];
				minid = j;//最小下标 第一次j=3
			}
		}
		cout << "V" <<adjvex[minid] << "-V" << minid << "=" << min << endl;
		sum += min;//最小生成树最小权值的和
		lowcost[minid] = 0;//将lowcost[3]=0即存入最小生成树
		for (j = 2; j <= n; j++)
		{
			if (graph[minid][j] < lowcost[j])//graph[3][j] lowcost[j]比较
			{
			    //若下标为minid顶点各边权值小于之前这些顶点未被加入最小生成树的权值
				lowcost[j] = graph[minid][j];//更新使得lowcost最小
				adjvex[j] = minid;
			}
		}
	}
	return sum;
}

int main()
{
	int i, j, k, m, n;
	int  cost;
	cin >> m >> n;//m=顶点的个数，n=边的个数
	//初始化图G
	for (i = 1; i <= m; i++)
	{
		for (j = 1; j <= m; j++)
		{
			graph[i][j] = MAXCOST;
		}
	}
	//构建图G
	for (k = 1; k <= n; k++)
	{
		cin >> i >> j >> cost;
		graph[i][j] = cost;
		graph[j][i] = cost;
	}
	//求解最小生成树
	cost = prim(graph, m);
	//输出最小权值和
	cout << "最小权值和=" << cost << endl;
	return 0;
}

 

---