最小生成树

合集下载

最小生成树MinimumSpanningTree

设邻接矩阵初值：不存在的边其权值为Infinity
8
1、Prim算法
算法求精－初始化
将根r涂红加入红点集U，TE＝φ。
对每个白点i (0≤i ≤n-1, i≠r ), i所关联的最短紫边（r,i）的长度为G[r][i], 这n-1条最短紫边构成了初始的候选轻边集。
因为树边为空，故将T[0..n-2]全部用来存放候选轻边集。
❖设V(G)={0,1,…,n-1}
❖算法的每一步均是在连接红、白点集的紫边中选一轻边扩充到T（贪心），T从任意一点r开始（r为根），直至U＝V为止。 MST性质保证了贪心选择策略的正确性。
3
1、Prim算法
如何找轻边？
❖可能的紫边集
设红点集|U|=k, 白点集|V-U|=n-k，则可能的紫边数为：k(n-k)。
//将(u,v)涂红加入树中，白点v加入红点集
ModifyCandidateSet(…);
//根据新红点v调整候选轻边集
}
}
算法终止时U＝V，T=(V,TE)
6
1、Prim算法
实例
6 1
5
35 4
05
1
3
27 2
4
5
6
60 5
1
1
3
∞2
∞
4
5
0
151
3
2
5
2 4
4
5
0
151
3
2
5
2 4
4
5
0
151 2
int i, minpos, min=Infinity; for (i=k; i<n-1; i++) //遍历候选集找轻边

最小生成树---普里姆算法（Prim算法）和克鲁斯卡尔算法（Kruskal算法）

最⼩⽣成树---普⾥姆算法（Prim算法）和克鲁斯卡尔算法（Kruskal算法）最⼩⽣成树的性质：MST性质（假设N=(V,{E})是⼀个连通⽹，U是顶点集V的⼀个⾮空⼦集，如果（u，v）是⼀条具有最⼩权值的边，其中u属于U，v属于V-U，则必定存在⼀颗包含边（u，v）的最⼩⽣成树）普⾥姆算法（Prim算法)思路：以点为⽬标构建最⼩⽣成树1.将初始点顶点u加⼊U中，初始化集合V-U中各顶点到初始顶点u的权值；2.根据最⼩⽣成树的定义：从n个顶点中，找出 n - 1条连线，使得各边权值最⼩。

循环n-1次如下操作：（1）从数组lowcost[k]中找到vk到集合U的最⼩权值边，并从数组arjvex[k] = j中找到该边在集合U中的顶点下标(2)打印此边，并将vk加⼊U中。

（3）通过查找邻接矩阵Vk⾏的各个权值，即vk点到V-U中各顶点的权值，与lowcost的对应值进⾏⽐较，若更⼩则更新lowcost，并将k存⼊arjvex数组中以下图为例#include<bits/stdc++.h>using namespace std;#define MAXVEX 100#define INF 65535typedef char VertexType;typedef int EdgeType;typedef struct {VertexType vexs[MAXVEX];EdgeType arc[MAXVEX][MAXVEX];int numVertexes, numEdges;}MGraph;void CreateMGraph(MGraph *G) {int m, n, w; //vm-vn的权重wscanf("%d %d", &G->numVertexes, &G->numEdges);for(int i = 0; i < G->numVertexes; i++) {getchar();scanf("%c", &G->vexs[i]);}for(int i = 0; i < G->numVertexes; i++) {for(int j = 0; j < G->numVertexes; j++) {if(i == j) G->arc[i][j] = 0;else G->arc[i][j] = INF;}}for(int k = 0; k < G->numEdges; k++) {scanf("%d %d %d", &m, &n, &w);G->arc[m][n] = w;G->arc[n][m] = G->arc[m][n];}}void MiniSpanTree_Prim(MGraph G) {int min, j, k;int arjvex[MAXVEX]; //最⼩边在 U集合中的那个顶点的下标int lowcost[MAXVEX]; // 最⼩边上的权值//初始化,从点 V0开始找最⼩⽣成树Tarjvex[0] = 0; //arjvex[i] = j表⽰ V-U中集合中的 Vi点的最⼩边在U集合中的点为 Vjlowcost[0] = 0; //lowcost[i] = 0表⽰将点Vi纳⼊集合 U ，lowcost[i] = w表⽰ V-U中 Vi点到 U的最⼩权值for(int i = 1; i < G.numVertexes; i++) {lowcost[i] = G.arc[0][i];arjvex[i] = 0;}//根据最⼩⽣成树的定义：从n个顶点中，找出 n - 1条连线，使得各边权值最⼩for(int i = 1; i < G.numVertexes; i++) {min = INF, j = 1, k = 0;//寻找 V-U到 U的最⼩权值minfor(j; j < G.numVertexes; j++) {// lowcost[j] != 0保证顶点在 V-U中，⽤k记录此时的最⼩权值边在 V-U中顶点的下标if(lowcost[j] != 0 && lowcost[j] < min) {min = lowcost[j];k = j;}}}printf("V[%d]-V[%d] weight = %d\n", arjvex[k], k, min);lowcost[k] = 0; //表⽰将Vk纳⼊ U//查找邻接矩阵Vk⾏的各个权值，与lowcost的对应值进⾏⽐较，若更⼩则更新lowcost，并将k存⼊arjvex数组中for(int i = 1; i < G.numVertexes; i++) {if(lowcost[i] != 0 && G.arc[k][i] < lowcost[i]) {lowcost[i] = G.arc[k][i];arjvex[i] = k;}}}int main() {MGraph *G = (MGraph *)malloc(sizeof(MGraph));CreateMGraph(G);MiniSpanTree_Prim(*G);}/*input:4 5abcd0 1 20 2 20 3 71 2 42 3 8output:V[0]-V[1] weight = 2V[0]-V[2] weight = 2V[0]-V[3] weight = 7最⼩总权值: 11*/时间复杂度O(n^2)克鲁斯卡尔算法（Kruskal算法）思路：以边为⽬标进⾏构建最⼩⽣成树在边集中依次寻找最⼩权值边，若构建是不形成环路（利⽤parent数组记录各点的连通分量），则将其添加到最⼩⽣成树中。

最小生成树的概念

最小生成树的概念
在图论中，最小生成树是一个连通图的生成树，其边的权值之和最小。

通俗地说，最
小生成树是指在一个图中找到一棵权值最小的生成树，这个生成树包含了连通图的所有顶点，且边的数量最小。

怎么找到最小生成树呢？有两种常用算法：Prim算法和Kruskal算法。

Prim算法首先任选一个点作为起点，然后在剩余的点中选择与当前集合距离最短的点加入集合，直到所有点被加入。

在加入每一个点时，找到与当前集合连接的距离最短的边，加入到生成树中。

重复以上步骤，直到所有点都被加入到生成树中。

Kruskal算法则是将边按照权值从小到大排序，选择权值最小的边加入到生成树中，
如果加入当前边后不构成环，则加入，否则继续找下一条权值最小的边。

重复以上步骤，
直到所有点都被加入到生成树中。

最小生成树有很广泛的应用，如在通信、传输、路网规划等领域都有很重要的作用。

在有些应用中，最小生成树不仅要求边的权值之和最小，还要满足一些约束条件，比如边
的数量、每个点的度数等，这时我们需要采用更加复杂的算法来求解问题。

最小生成树的应用非常广泛，比如在计算机网络中，路由协议需要找到最短的数据传
输路径；在城市交通中，规划出最优的交通路径能够有效减少能源的消耗；在电力系统中，设计最短的输电线路可以节省能源成本。

最小生成树的运用如此广泛，它不仅在计算机科
学中有重要作用，也在其他各个领域有着不可替代的作用。

最小生成树

然后从那些其一个端点已在U中，另一个端点仍在U外的所有边中，找一条最短（即权值最小）的边，假定该边为(Vi,Vj),其中Vi∈U， Vj∈V-U,并把该边(Vi,Vj)和顶点Vj分别并入T的边集TE和顶点集U；图
如此进行下去，每次往生成树里并入一个顶点和一条边，直到n-1次后，把所有 n 个顶点都并入生成树T的顶点集U中，此时U=V，TE中包含有（n-1）条边；
图
图6.10 图G 及其生成树
无向连通图 G 图
➢ 生成树
图6.10 图G 及其生成树
生成树
➢ 最小生成树
图
1.1 普里姆(prim)算法
假设G=(V,E)是一个具有n 个顶点的连通网络， T=(U,TE)是G的最小生成树，其中U是T的顶点集，TE是T的边集，U和TE的初值均为空。
算法开始时，首先从V中任取一个顶点（假定为V1），将此顶点并入U中，此时最小生成树顶点集U={V1}；
这样，T就是最后得到的最小生成树。
普里姆算法中每次选取的边两端，总是一个已连通顶点（在U集合内）和一个未连通顶点（在U集合外），故这个边选取后一定能将未连通顶点连通而又保证不会形成环路。
图
图6.11 普里姆算法例子
图
为了便于在顶点集合U和V-U之间选择权最小的边，建立两个数组closest和 lowcost,closest[i]表示U中的一个顶点，该顶点与V-U中的一个顶点构成的边具有最小的权；lowcost表示该边对应的权值。
姆
{
算
min=lowcost[j];
法
k=j;
续
} printf(“(%d,%d)”,k,closest[j]);
/* 打印生成树的一条边*/

最短路径与最小生成树的区别

最短路径与最小生成树的区别
在图论中，最短路径和最小生成树是两个重要的概念。

它们都是用来解决图中节点之间的距离问题，但是它们的解决方法和目的却有所不同。

最短路径问题是指在一个有向或无向加权图中，找到从一个节点到另一个节点最短的路径。

最短路径可以使用Dijkstra算法和Bellman-Ford算法来解决。

这类问题通常是求出从一个节点到其他节点的最短距离，通常用于网络路由、GPS导航等应用。

最小生成树问题是指在一个无向加权图中，找到一个生成树，使得该树中的所有边权之和最小。

最小生成树可以使用Prim算法和Kruskal算法来求解。

这类问题通常是在需要将图连接起来的场合，比如铺设电缆、通信网络等场合。

因此，最短路径问题和最小生成树问题虽然都与计算节点间距离有关，但是它们的解决方法和应用场景却有很大的差异。

在具体应用中，需要根据实际情况选择合适的算法和方法来解决问题。

- 1 -。

离散数学最小生成树例题

离散数学最小生成树例题（实用版）目录1.最小生成树的概念和性质2.最小生成树的算法原理3.最小生成树的算法举例4.最小生成树的应用实例正文一、最小生成树的概念和性质最小生成树（Minimum Spanning Tree，简称 MST）是指在一个加权连通图中，选择一些边，使得所有节点都能被联通，并且边代价之和最小。

最小生成树具有以下性质：1.树中的边是最短的边：在生成树中，任意两个节点之间的边都是最短的边，即不存在比这条边更短的边能连接这两个节点。

2.树是没有圈的：最小生成树显然不应该有圈，因为如果有圈，可以通过删除圈中的一条边来形成一个更小的生成树。

二、最小生成树的算法原理求解最小生成树的经典算法有 Kruskal 算法和 Prim 算法。

这里我们以 Prim 算法为例介绍最小生成树的算法原理。

Prim 算法的基本思想是从一个初始节点开始，不断地寻找与当前生成树距离最近的节点，将其加入到生成树中，直到所有节点都加入到生成树中为止。

在寻找距离最近的节点时，我们需要使用贪心策略，即每次都选择距离最近的节点。

为了判断一个节点是否已经加入了生成树，我们可以使用并查集数据结构。

三、最小生成树的算法举例这里我们以一个简单的例子来说明 Prim 算法的求解过程。

假设有一个图，共有 4 个节点，5 条边，边的权值分别为 1, 2, 3, 4, 5。

我们选择节点 1 作为初始节点，按照 Prim 算法的步骤，可以得到最小生成树的权值为 9，生成树如下所示：```1 --2 --3 -- 4```四、最小生成树的应用实例最小生成树在实际应用中有很多实例，如网络路由、数据压缩、图像处理等。

这里我们以网络路由为例，介绍最小生成树的应用。

在网络中，为了提高传输效率，我们需要在网络中建立一条最短路径。

通过求解最小生成树，我们可以得到网络中的最短路径，从而为数据包的传输提供指导。

在求解最小生成树时，我们可以将网络中的节点看作是图的顶点，边看作是图的边，边的权值看作是节点之间的距离。

最小生成树（普里姆算法）

最⼩⽣成树（普⾥姆算法）：所谓⽣成树，就是n个点之间连成n-1条边的图形。

⽽最⼩⽣成树，就是权值（两点间直线的值）之和的最⼩值。

⾸先，要⽤⼆维数组记录点和权值。

如上图所⽰⽆向图：int map[7][7];map[1][2]=map[2][1]=4;map[1][3]=map[3][1]=2;......然后再求最⼩⽣成树。

具体⽅法是：1.先选取⼀个点作起始点，然后选择它邻近的权值最⼩的点（如果有多个与其相连的相同最⼩权值的点，随便选取⼀个）。

如1作为起点。

visited[1]=1;pos=1;//⽤low[]数组不断刷新最⼩权值，low[i](0<i<=点数)的值为：i点到邻近点（未被标记）的最⼩距离。

low[1]=0; //起始点i到邻近点的最⼩距离为0low[2]=map[pos][2]=4;low[3]=map[pos][3]=2;low[4]==map[pos][4]=3;low[5]=map[pos][5]=MaxInt; //⽆法直达low[6]=map[pos][6]=MaxInt;2.再在伸延的点找与它邻近的两者权值最⼩的点。

//low[]以3作当前位置进⾏更新visited[3]=1;pos=3;low[1]=0; //已标记，不更新low[2]=map[1][2]=4; //⽐5⼩，不更新low[3]=2; //已标记，不更新low[4]=map[1][4]=3; //⽐1⼤，更新后为：low[4]=map[3][4]=1;low[5]=map[1][5]=MaxInt;//⽆法直达，不更新low[6]=map[1][6]=MaxInt;//⽐2⼤，更新后为：low[6]=map[3][6]=2;3.如此类推...当所有点都连同后，结果最⽣成树如上图所⽰。

所有权值相加就是最⼩⽣成树，其值为2+1+2+4+3=12。

⾄于具体代码如何实现，现在结合POJ1258例题解释。

最小生成树算法详解

最小生成树算法详解最小生成树（Minimum Spanning Tree，简称MST）是图论中的一个经典问题，它是指在一个加权连通图中找出一棵包含所有顶点且边权值之和最小的树。

在解决实际问题中，最小生成树算法被广泛应用于网络规划、电力传输、城市道路建设等领域。

本文将详细介绍最小生成树算法的原理及常见的两种算法：Prim算法和Kruskal算法。

一、最小生成树算法原理最小生成树算法的核心思想是贪心算法。

其基本原理是从图的某个顶点开始，逐步选取当前顶点对应的边中权值最小的边，并确保选取的边不会构成环，直到所有顶点都被连接为止。

具体实现最小生成树算法的方法有多种，两种常见的算法是Prim 算法和Kruskal算法。

二、Prim算法Prim算法是一种基于顶点的贪心算法。

它从任意一个顶点开始，逐渐扩展生成树的规模，直到生成整个最小生成树。

算法的具体步骤如下：1. 初始化一个空的生成树集合和一个空的顶点集合，将任意一个顶点加入到顶点集合中。

2. 从顶点集合中选择一个顶点，将其加入到生成树集合中。

3. 以生成树集合中的顶点为起点，寻找与之相邻的顶点中权值最小的边，并将该边与对应的顶点加入到最小生成树中。

4. 重复第3步，直到生成树中包含所有顶点。

Prim算法是一种典型的贪心算法，其时间复杂度为O(V^2)，其中V为顶点数。

三、Kruskal算法Kruskal算法是一种基于边的贪心算法。

它首先将所有边按照权值从小到大进行排序，然后从小到大依次选择边，判断选取的边是否与已选取的边构成环，若不构成环，则将该边加入到最小生成树中。

算法的具体步骤如下：1. 初始化一个空的生成树集合。

2. 将图中的所有边按照权值进行排序。

3. 依次选择权值最小的边，判断其两个顶点是否属于同一个连通分量，若不属于，则将该边加入到最小生成树中。

4. 重复第3步，直到最小生成树中包含所有顶点。

Kruskal算法通过并查集来判断两个顶点是否属于同一个连通分量，从而避免形成环。

最小生成树

对于图G=(V,E)的每一条e∈E, 赋予相应的权数 f(e),得到一个网络图，记为N＝（V,E,F）,
设T＝（为T的权，N中权数最小的生成树称为N的最小生成树。许多实际问题，如在若干个城市之间建造铁路网、输电网或通信网等，都可归纳为寻求连通赋权图的最小生成树问题。下面介绍两种求最小生成树的方法：
例1 求下图所示的最小生成树。
v2 e1 v1 e2 e6 v4 e 7 v3
v5
解：按各边的权的不减次序为：
e1 e 2 e3 e7 e6 e 4 e5 e8
所以，首先取 e1 , e2 ,尔后再取 e7 和 e6 , 则构成最小生成树 .
二、破圈法破圈法就是在图中任取一个圈，从圈中去掉权最大的边，将这个圈破掉。重复这个过程，直到图中没有圈为止，保留下的边组成的图即为最小生成树。例2 同例1。解：在圈v2v2v3中，去掉权最大的边e2或e3；在圈v2v3v4中，去掉权最大的边e4；在圈v3v4v5中，去掉权最大的边e5；在圈中v2v3v5，去掉权最大的边e8；
在剩下的图中，已没有圈，于是得到最小生成树，如下图：
v2 e1 v1 e2 e6 v4 v3 e7
v5
例3 求下图的最小生成树。
C1 1 B1 3 5 A 4 B2 6 5 8 7 6 C4 C3 3 3 4 D3 8 3 C2 8 D2 4 E A
4 3 B2 C4 4 D3 C3 3
B 2 A 3 5 J 2 2 H 5 G 1 F 2 1 S 3 1 4 C 3 4 1 4 E
5
D 2
A 2
B
1
C D 1 2 E
1 S 2 H

欧拉定律和最小生成树

欧拉定律（Euler's Law）欧拉定律是由瑞士数学家欧拉（Leonhard Euler）在18世纪中叶提出的一个重要定律。

它描述了在一个连通的平面图中，顶点的度数（即与该顶点相连的边的数量）的性质。

根据欧拉定律，一个连通的平面图中满足以下条件：若图中有一个或多个顶点的度数为奇数，则此图不是欧拉图（Eulerian graph）；若所有顶点的度数都为偶数，则此图是欧拉图。

对于一个连通平面图，它至少存在一条欧拉路径（Eulerian path），即从某个顶点开始，沿着边行走，可以遍历图中所有边且各边只经过一次。

（欧拉路径可以从任意顶点出发）对于一个连通平面图，要满足存在欧拉回路（Eulerian circuit），即从某个顶点出发，可以遍历图中所有边且各边只经过一次，并最终回到出发顶点。

最小生成树（Minimum Spanning Tree）最小生成树是在一个无向连通图中，选择连通所有顶点的一棵树，并使得树的所有边权重之和最小的一种树结构。

最小生成树问题通常用于求解网络、运输和通信等领域中的优化问题。

常用的算法包括Prim算法和Kruskal算法。

Prim算法（Prim's Algorithm）: 从一个起始顶点开始，每次选择与已选顶点集合最近的一个顶点，并将其加入集合，直到所有顶点被加入。

Kruskal算法（Kruskal's Algorithm）: 将边按照权重从小到大排序，逐个加入到生成树中，只要边加入不构成闭合回路即可。

最小生成树的应用广泛，比如在通信网络中优化传输成本、在城市规划中优化建设成本等。

它可以帮助我们找到满足条件的连通子图，在保证最小总成本的前提下建立起高效的连接关系。

最小生成树

int a,b;//边的两个顶点的编号 int d;//边的权值
}edge[111边的条数,s用来存放最小生成树的总权值 int root[111];//存储父节点
bool cmp(Edge a,Edge b) {
return a.d<b.d; } int find(int a)//寻找父节点
T1
u
顶点集 U
u'
T2 v
顶点集 V－U
13
应用举例——最小生成树
Prim算法
34 B 12
A 19
26 E
F
46 25
25 38
C
D
17
U={A}
V-U={B, C, D, E, F}
cost={(A, B)34, (A, C)46, (A, D)∞, (A, E)∞, (A, F)19}
最小生成树
生成树是一个连通图G的一个极小连通子图。包含G的所有n个顶点，但只有n-1条边，并且是连通的。
当生成树中所包含的边的权值和最小，我们称之为最小生成树。
最小生成树性质
最小生成树的边数必然是顶点数减一，|E| = |V| - 1。最小生成树不可以有循环。最小生成树不必是唯一的。
16
应用举例——最小生成树
Prim算法
34 B 12
A 19
26 E
F
46 25
25 38
C
D
17
U={A, F, C, D} V-U={B, E} cost={(A, B)34, (F, E)26}
{ if(root[a]==a) return a; return root[a]=find(root[a]);

最小生成树的方法

最小生成树的方法
最小生成树（Minimum Spanning Tree）是指在一个带权无向连通图中，找到一个包含所有顶点且总权值最小的树。

常用的方法有以下几种：
1. Prim算法（普里姆算法）：从一个起始顶点开始，逐步扩展生成树，每次选择一个与当前生成树距离最小的顶点加入，直到所有顶点都被包含在生成树中。

2. Kruskal算法（克鲁斯卡尔算法）：首先将图的所有边按照权值从小到大排序，然后依次选择权值最小的边加入生成树中，但要保证加入边后不会形成环，直到生成树中包含所有顶点，或者图中的所有边都被考虑过。

3. Boruvka算法（博鲁卡尔算法）：将图的所有顶点分成多个不相交的集合，每个集合中的顶点组成一棵生成树，然后每次选择具有最小权值且连接两个不同集合的边加入生成树中，直到只剩下一个集合。

4. Jarnik算法（加尔尼克算法）：也称为更改版的Prim算法，首先选择一个起始顶点加入生成树中，然后通过比较当前生成树中的顶点到其他顶点的距离，选择一个距离最小的顶点加入生成树，重复该过程直到所有顶点都被包含在生成树中。

这些方法都可以得到最小生成树，但在某些情况下，它们的效率和性能可能会不同。

选择合适的方法取决于具体的应用场景和图的特征。

最小生成树应用场合

最小生成树算法
1.网络布局问题：在一个连通加权无向图中，最小生成树算法可以帮助找到一个包含所有顶点的最小权重树，从而在地图上实现有效的布局。

2.地图着色问题：在地图着色问题中，最小生成树算法可以用于优化颜色分配，使得相邻区域的颜色不同，同时最小化所需的颜色数量。

3.车辆路径优化问题：在物流和运输行业中，最小生成树算法可以用于优化车辆的行驶路径，使得车辆能够更高效地完成配送任务，降低运输成本。

4.通信网络设计：在通信网络设计中，最小生成树算法可以用于构建高效的数据传输网络，使得数据能够在不同的节点之间快速传输。

5.电力系统设计：在电力系统的设计中，最小生成树算法可以用于构建高效的输电网络，使得电能能够从发电厂传输到各个用户。

请注意，这些应用场景中都需要用到最小生成树算法来寻找最优解。

详解图的应用(最小生成树、拓扑排序、关键路径、最短路径)

详解图的应用（最小生成树、拓扑排序、关键路径、最短路径）1.最小生成树：无向连通图的所有生成树中有一棵边的权值总和最小的生成树1.1 问题背景：假设要在n个城市之间建立通信联络网，则连通n个城市只需要n—1条线路。

这时，自然会考虑这样一个问题，如何在最节省经费的前提下建立这个通信网。

在每两个城市之间都可以设置一条线路，相应地都要付出一定的经济代价。

n个城市之间，最多可能设置n(n-1)/2条线路，那么，如何在这些可能的线路中选择n-1条，以使总的耗费最少呢?1.2 分析问题（建立模型）：可以用连通网来表示n个城市以及n个城市间可能设置的通信线路，其中网的顶点表示城市，边表示两城市之间的线路，赋于边的权值表示相应的代价。

对于n个顶点的连通网可以建立许多不同的生成树，每一棵生成树都可以是一个通信网。

即无向连通图的生成树不是唯一的。

连通图的一次遍历所经过的边的集合及图中所有顶点的集合就构成了该图的一棵生成树，对连通图的不同遍历，就可能得到不同的生成树。

图G5无向连通图的生成树为(a)、(b)和(c)图所示：G5G5的三棵生成树：可以证明，对于有n 个顶点的无向连通图，无论其生成树的形态如何，所有生成树中都有且仅有n－1 条边。

1.3最小生成树的定义：如果无向连通图是一个网，那么，它的所有生成树中必有一棵边的权值总和最小的生成树，我们称这棵生成树为最小生成树，简称为最小生成树。

最小生成树的性质：假设N=(V,{ E}) 是个连通网，U是顶点集合V的一个非空子集，若（u,v）是个一条具有最小权值(代价)的边，其中，则必存在一棵包含边（u,v）的最小生成树。

1.4 解决方案：两种常用的构造最小生成树的算法：普里姆（Prim）和克鲁斯卡尔（Kruskal）。

他们都利用了最小生成树的性质1.普里姆（Prim）算法：有线到点，适合边稠密。

时间复杂度O(N^2)假设G＝（V，E）为连通图，其中V 为网图中所有顶点的集合，E 为网图中所有带权边的集合。

最小生成树唯一的充要条件

最小生成树唯一的充要条件最小生成树是图论中的一个重要概念，它是一棵生成树，包含所有图中的节点，并且具有最小的总权值。

在实际应用中，最小生成树被广泛运用于网络设计、城市规划等领域，因此，了解最小生成树的充要条件对于深入理解这些应用至关重要。

接下来，我们将介绍最小生成树唯一的充要条件。

一、什么是最小生成树最小生成树指的是一个无向图的生成树，它的所有边的权值之和最小。

一个无向图的生成树是指一棵树，包含所有图中的节点，并且只有图中的边。

因此，最小生成树是一个无向图的一种特殊情况。

二、最小生成树的唯一充要条件最小生成树有一个重要的性质，即它是唯一的当且仅当该无向图中不存在权值相同的边。

具体来说，设有一个无向图G=(V,E)，其中V是节点的集合，E是边的集合。

假设生成树T是G的一个生成树，我们需要证明最小生成树T是唯一的当且仅当G中不存在权值相同的边。

充分性证明：首先，假设最小生成树T是唯一的，我们需要证明G中不存在权值相同的边。

假设存在权值相同的边e1和e2，它们的权值都为w。

根据前提条件，T是最小生成树，因此T必须包含一条边e1或e2，假设T包含边e1，那么将边e1替换成e2，得到一棵新的生成树T'。

此时，T'中还有n-2条边需要加入。

因为T是最小生成树，所以T'的总权值必须大于等于T的总权值。

但是，由于e1和e2都是权值为w的边，所以将其替换不会改变T的总权值，即T'的总权值等于T的总权值。

因此，T'不能是最小生成树，与前提条件不符。

综上所述，最小生成树T是唯一的，则G中不存在权值相同的边。

必要性证明：然后，我们需要证明G中不存在权值相同的边，则最小生成树T是唯一的。

假设存在两棵生成树T1和T2，它们的权值之和相等，但是它们不相同。

由于T1和T2都是生成树，因此它们都包含n-1条边。

我们假设T1中有一条边e不在T2中，而T2中有一条边f不在T1中。

由于e不在T2中，因此e和f可以构成一个环。

数据结构（三十三）最小生成树（Prim、Kruskal）

数据结构（三⼗三）最⼩⽣成树（Prim、Kruskal）⼀、最⼩⽣成树的定义⼀个连通图的⽣成树是⼀个极⼩的连通⼦图，它含有图中全部的顶点，但只有⾜以构成⼀棵树的n-1条边。

在⼀个⽹的所有⽣成树中，权值总和最⼩的⽣成树称为最⼩代价⽣成树（Minimum Cost Spanning Tree），简称为最⼩⽣成树。

构造最⼩⽣成树的准则有以下3条：只能使⽤该图中的边构造最⼩⽣成树当且仅当使⽤n-1条边来连接图中的n个顶点不能使⽤产⽣回路的边对⽐两个算法，Kruskal算法主要是针对边来展开，边数少时效率会⾮常⾼，所以对于稀疏图有很⼤的优势；⽽Prim算法对于稠密图，即边数⾮常多的情况会更好⼀些。

⼆、普⾥姆（Prim）算法 1.Prim算法描述假设N={V,{E}}是连通⽹，TE是N上最⼩⽣成树中边的集合。

算法从U={u0，u0属于V}，TE={}开始。

重复执⾏下⾯的操作：在所有u属于U，v 属于V-U的边(u,v)中找⼀条代价最⼩的边(u0,v0)并加⼊集合TE，同时v0加⼊U，直到U=V为⽌。

此时TE中必有n-1条边，则T=(V,{TE})为N的最⼩⽣成树。

2.Prim算法的C语⾔代码实现/* Prim算法⽣成最⼩⽣成树 */void MiniSpanTree_Prim(MGraph G){int min, i, j, k;int adjvex[MAXVEX]; /* 保存相关顶点下标 */int lowcost[MAXVEX]; /* 保存相关顶点间边的权值 */lowcost[0] = 0;/* 初始化第⼀个权值为0，即v0加⼊⽣成树 *//* lowcost的值为0，在这⾥就是此下标的顶点已经加⼊⽣成树 */adjvex[0] = 0; /* 初始化第⼀个顶点下标为0 */for(i = 1; i < G.numVertexes; i++) /* 循环除下标为0外的全部顶点 */{lowcost[i] = G.arc[0][i]; /* 将v0顶点与之有边的权值存⼊数组 */adjvex[i] = 0; /* 初始化都为v0的下标 */}for(i = 1; i < G.numVertexes; i++){min = INFINITY; /* 初始化最⼩权值为∞， *//* 通常设置为不可能的⼤数字如32767、65535等 */j = 1;k = 0;while(j < G.numVertexes) /* 循环全部顶点 */{if(lowcost[j]!=0 && lowcost[j] < min)/* 如果权值不为0且权值⼩于min */{min = lowcost[j]; /* 则让当前权值成为最⼩值 */k = j; /* 将当前最⼩值的下标存⼊k */}j++;}printf("(%d, %d)\n", adjvex[k], k);/* 打印当前顶点边中权值最⼩的边 */lowcost[k] = 0;/* 将当前顶点的权值设置为0,表⽰此顶点已经完成任务 */for(j = 1; j < G.numVertexes; j++) /* 循环所有顶点 */{if(lowcost[j]!=0 && G.arc[k][j] < lowcost[j]){/* 如果下标为k顶点各边权值⼩于此前这些顶点未被加⼊⽣成树权值 */lowcost[j] = G.arc[k][j];/* 将较⼩的权值存⼊lowcost相应位置 */adjvex[j] = k; /* 将下标为k的顶点存⼊adjvex */}}}}Prim算法 3.Prim算法的Java语⾔代码实现package bigjun.iplab.adjacencyMatrix;/*** 最⼩⽣成树之Prim算法*/public class MiniSpanTree_Prim {int lowCost; // 顶点对应的权值public CloseEdge(Object adjVex, int lowCost) {this.adjVex = adjVex;this.lowCost = lowCost;}}private static int getMinMum(CloseEdge[] closeEdges) {int min = Integer.MAX_VALUE; // 初始化最⼩权值为正⽆穷int v = -1; // 顶点数组下标for (int i = 0; i < closeEdges.length; i++) { // 遍历权值数组，找到最⼩的权值以及对应的顶点数组的下标if (closeEdges[i].lowCost != 0 && closeEdges[i].lowCost < min) {min = closeEdges[i].lowCost;v = i;}}return v;}// Prim算法构造图G的以u为起始点的最⼩⽣成树public static void Prim(AdjacencyMatrixGraphINF G, Object u) throws Exception{// 初始化⼀个⼆维最⼩⽣成树数组minSpanTree，由于最⼩⽣成树的边是n-1，所以数组第⼀个参数是G.getVexNum() - 1，第⼆个参数表⽰边的起点和终点符号，所以是2 Object[][] minSpanTree = new Object[G.getVexNum() - 1][2];int count = 0; // 最⼩⽣成树得到的边的序号// 初始化保存相关顶点和相关顶点间边的权值的数组对象CloseEdge[] closeEdges = new CloseEdge[G.getVexNum()];int k = G.locateVex(u);for (int j = 0; j < G.getVexNum(); j++) {if (j!=k) {closeEdges[j] = new CloseEdge(u, G.getArcs()[k][j]);// 将顶点u到其他各个顶点权值写⼊数组中}}closeEdges[k] = new CloseEdge(u, 0); // 加⼊u到⾃⾝的权值0for (int i = 1; i < G.getVexNum(); i++) { // 注意，这⾥从1开始，k = getMinMum(closeEdges); // 获取u到数组下标为k的顶点的权值最短minSpanTree[count][0] = closeEdges[k].adjVex; // 最⼩⽣成树第⼀个值为uminSpanTree[count][1] = G.getVexs()[k]; // 最⼩⽣成树第⼆个值为k对应的顶点count++;closeEdges[k].lowCost = 0; // 下标为k的顶点不参与最⼩权值的查找了for (int j = 0; j < G.getVexNum(); j++) {if (G.getArcs()[k][j] < closeEdges[j].lowCost) {closeEdges[j] = new CloseEdge(G.getVex(k), G.getArcs()[k][j]);}}}System.out.print("通过Prim算法得到的最⼩⽣成树序列为: {");for (Object[] Tree : minSpanTree) {System.out.print("(" + Tree[0].toString() + "-" + Tree[1].toString() + ")");}System.out.println("}");}} 4.举例说明Prim算法实现过程以下图为例：测试类：// ⼿动创建⼀个⽤于测试最⼩⽣成树算法的⽆向⽹public static AdjacencyMatrixGraphINF createUDNByYourHand_ForMiniSpanTree() {Object vexs_UDN[] = {"V0", "V1", "V2", "V3", "V4", "V5", "V6", "V7", "V8"};int arcsNum_UDN = 15;int[][] arcs_UDN = new int[vexs_UDN.length][vexs_UDN.length];for (int i = 0; i < vexs_UDN.length; i++) // 构造⽆向图邻接矩阵for (int j = 0; j < vexs_UDN.length; j++)if (i==j) {arcs_UDN[i][j]=0;} else {arcs_UDN[i][j] = arcs_UDN[i][j] = INFINITY;}arcs_UDN[0][5] = 11;arcs_UDN[1][2] = 18;arcs_UDN[1][6] = 16;arcs_UDN[1][8] = 12;arcs_UDN[2][3] = 22;arcs_UDN[2][8] = 8;arcs_UDN[3][4] = 20;arcs_UDN[3][6] = 24;arcs_UDN[3][7] = 16;arcs_UDN[3][8] = 21;arcs_UDN[4][5] = 26;arcs_UDN[4][7] = 7;arcs_UDN[5][6] = 17;arcs_UDN[6][7] = 19;for (int i = 0; i < vexs_UDN.length; i++) // 构造⽆向图邻接矩阵for (int j = i; j < vexs_UDN.length; j++)arcs_UDN[j][i] = arcs_UDN[i][j];return new AdjMatGraph(GraphKind.UDN, vexs_UDN.length, arcsNum_UDN, vexs_UDN, arcs_UDN);}public static void main(String[] args) throws Exception {AdjMatGraph UDN_Graph = (AdjMatGraph) createUDNByYourHand_ForMiniSpanTree();MiniSpanTree_Prim.Prim(UDN_Graph, "V0");} 输出为：通过Prim算法得到的最⼩⽣成树序列为: {(V0-V1)(V0-V5)(V1-V8)(V8-V2)(V1-V6)(V6-V7)(V7-V4)(V7-V3)} 分析算法执⾏过程：从V0开始：-count为0，k为0，closeEdges数组的-lowCost为{0 10 INF INF INF 11 INF INF INF}，adjVex数组为{V0，V0，V0，V0，V0，V0，V0，V0，V0}-⽐较lowCost，于是k为1，adjVex[1]为V0，minSpanTree[0]为（V0，V1），lowCost为{0 0 INF INF INF 11 INF INF INF}-k为1，与V1的权值⾏⽐较，得到新的-lowCost为：{0 0 18 INF INF 11 16 INF 12}，adjVex数组为{V0，V0，V1，V0，V0，V0，V1，V0，V1}-⽐较lowCost，于是k为5，adjVex[5]为V0，minSpanTree[1]为（V0，V5），lowCost为{0 0 18 INF INF 0 16 INF 12}-k为5，与V5的权值⾏⽐较，得到新的-lowCost为{0 0 18 INF 26 0 16 INF 12}，adjVex数组为{V0，V0，V1，V0，V5，V0，V1，V0，V1}-⽐较lowCost，于是k为8，adjVex[8]为V1，minSpanTree[2]为（V1，V8），lowCost为{0 0 18 INF INF 0 16 INF 0}... 三、克鲁斯卡尔（Kruskal）算法 1.Kruskal算法描述 Kruskal算法是根据边的权值递增的⽅式，依次找出权值最⼩的边建⽴的最⼩⽣成树，并且规定每次新增的边，不能造成⽣成树有回路，直到找到n-1条边为⽌。