图论—最小生成树模板
3 图论—最小生成树3.1 最小生成树(kruskal邻接表)//无向图最小生成树,kruskal算法,邻接表形式,复杂度O(mlogm)//返回最小生成树的长度,传入图的大小n和邻接表list//可更改边权的类型,edge[][2]返回树的构造,用边集表示//如果图不连通,则对各连通分支构造最小生成树,返回总长度#include <string.h>#define MAXN 200#define inf 1000000000typedef double elem_t;struct edge_t{int from,to;elem_t len;edge_t* next;};#define _ufind_run(x) for(;p[t=x];x=p[x],p[t]=(p[x]?p[x]:x))#define _run_both _ufind_run(i);_ufind_run(j)struct ufind{int p[MAXN],t;void init(){memset(p,0,sizeof(p));}void set_friend(int i,int j){_run_both;p[i]=(i==j?0:j);}int is_friend(int i,int j){_run_both;return i==j&&i;}};#define _cp(a,b) ((a).len<(b).len)struct heap_t{int a,b;elem_t len;};struct minheap{heap_t h[MAXN*MAXN];int n,p,c;void init(){n=0;}void ins(heap_t e){for (p=++n;p>1&&_cp(e,h[p>>1]);h[p]=h[p>>1],p>>=1);h[p]=e;}int del(heap_t& e){if (!n) return 0;for(e=h[p=1],c=2;c<n&&_cp(h[c+=(c<n-1&&_cp(h[c+1],h[c]))],h[n]);h[p]=h[c],p=c,c<<=1);h[p]=h[n--];return 1;}};elem_t kruskal(int n,edge_t* list[],int edge[][2]){ufind u;minheap h;edge_t* t;heap_t e;elem_t ret=0;int i,m=0;u.init(),h.init();for (i=0;i<n;i++)for (t=list[i];t;t=t->next)if (i<t->to)e.a=i,e.b=t->to,e.len=t->len,h.ins(e);while (m<n-1&&h.del(e))if (!u.is_friend(e.a+1,e.b+1))edge[m][0]=e.a,edge[m][1]=e.b,ret+=e.len,u.set_friend(e.a+1,e.b+1);return ret;}3.2 最小生成树(kruskal正向表)//无向图最小生成树,kruskal算法,正向表形式,复杂度O(mlogm)//返回最小生成树的长度,传入图的大小n和正向表list,buf//可更改边权的类型,edge[][2]返回树的构造,用边集表示//如果图不连通,则对各连通分支构造最小生成树,返回总长度#include <string.h>#define MAXN 200#define inf 1000000000typedef double elem_t;struct edge_t{int to;elem_t len;};#define _ufind_run(x) for(;p[t=x];x=p[x],p[t]=(p[x]?p[x]:x))#define _run_both _ufind_run(i);_ufind_run(j)struct ufind{int p[MAXN],t;void init(){memset(p,0,sizeof(p));}void set_friend(int i,int j){_run_both;p[i]=(i==j?0:j);}int is_friend(int i,int j){_run_both;return i==j&&i;}};#define _cp(a,b) ((a).len<(b).len)struct heap_t{int a,b;elem_t len;};struct minheap{heap_t h[MAXN*MAXN];int n,p,c;void init(){n=0;}void ins(heap_t e){for (p=++n;p>1&&_cp(e,h[p>>1]);h[p]=h[p>>1],p>>=1);h[p]=e;}int del(heap_t& e){if (!n) return 0;for(e=h[p=1],c=2;c<n&&_cp(h[c+=(c<n-1&&_cp(h[c+1],h[c]))],h[n]);h[p]=h[c],p=c,c<<=1);h[p]=h[n--];return 1;}};elem_t kruskal(int n,int* list,edge_t* buf,int edge[][2]){ufind u;minheap h;heap_t e;elem_t ret=0;int i,j,m=0;u.init(),h.init();for (i=0;i<n;i++)for (j=list[i];j<list[i+1];j++)if (i<buf[j].to)e.a=i,e.b=buf[j].to,e.len=buf[j].len,h.ins(e);while (m<n-1&&h.del(e))if (!u.is_friend(e.a+1,e.b+1))edge[m][0]=e.a,edge[m][1]=e.b,ret+=e.len,u.set_friend(e.a+1,e.b+1);return ret;}3.3 最小生成树(prim+binary_heap邻接表)//无向图最小生成树,prim算法+二分堆,邻接表形式,复杂度O(mlogm)//返回最小生成树的长度,传入图的大小n和邻接表list//可更改边权的类型,pre[]返回树的构造,用父结点表示,根节点(第一个)pre值为-1//必须保证图的连通的!#define MAXN 200#define inf 1000000000typedef double elem_t;struct edge_t{int from,to;elem_t len;edge_t* next;};#define _cp(a,b) ((a).d<(b).d)struct heap_t{elem_t d;int v;};struct heap{heap_t h[MAXN*MAXN];int n,p,c;void init(){n=0;}void ins(heap_t e){for (p=++n;p>1&&_cp(e,h[p>>1]);h[p]=h[p>>1],p>>=1);h[p]=e;}int del(heap_t& e){if (!n) return 0;for(e=h[p=1],c=2;c<n&&_cp(h[c+=(c<n-1&&_cp(h[c+1],h[c]))],h[n]);h[p]=h[c],p=c,c<<=1);h[p]=h[n--];return 1;}};elem_t prim(int n,edge_t* list[],int* pre){heap h;elem_t min[MAXN],ret=0;edge_t* t;heap_t e;int v[MAXN],i;for (i=0;i<n;i++)min[i]=inf,v[i]=0,pre[i]=-1;h.init();e.v=0,e.d=0,h.ins(e);while (h.del(e))if (!v[e.v])for (v[e.v]=1,ret+=e.d,t=list[e.v];t;t=t->next)if (!v[t->to]&&t->len<min[t->to])pre[t->to]=t->from,min[e.v=t->to]=e.d=t->len,h.ins(e);return ret;}3.4 最小生成树(prim+binary_heap正向表)//无向图最小生成树,prim算法+二分堆,正向表形式,复杂度O(mlogm)//返回最小生成树的长度,传入图的大小n和正向表list,buf//可更改边权的类型,pre[]返回树的构造,用父结点表示,根节点(第一个)pre值为-1//必须保证图的连通的!#define MAXN 200#define inf 1000000000typedef double elem_t;struct edge_t{int to;elem_t len;};#define _cp(a,b) ((a).d<(b).d)struct heap_t{elem_t d;int v;};struct heap{heap_t h[MAXN*MAXN];int n,p,c;void init(){n=0;}void ins(heap_t e){for (p=++n;p>1&&_cp(e,h[p>>1]);h[p]=h[p>>1],p>>=1);h[p]=e;}int del(heap_t& e){if (!n) return 0;for(e=h[p=1],c=2;c<n&&_cp(h[c+=(c<n-1&&_cp(h[c+1],h[c]))],h[n]);h[p]=h[c],p=c,c<<=1);h[p]=h[n--];return 1;}};elem_t prim(int n,int* list,edge_t* buf,int* pre){heap h;heap_t e;elem_t min[MAXN],ret=0;int v[MAXN],i,j;for (i=0;i<n;i++)min[i]=inf,v[i]=0,pre[i]=-1;h.init();e.v=0,e.d=0,h.ins(e);while (h.del(e))if (!v[i=e.v])for (v[i]=1,ret+=e.d,j=list[i];j<list[i+1];j++)if (!v[buf[j].to]&&buf[j].len<min[buf[j].to])pre[buf[j].to]=i,min[e.v=buf[j].to]=e.d=buf[j].len,h.ins(e);return ret;}3.5 最小生成树(prim+mapped_heap邻接表)//无向图最小生成树,prim算法+映射二分堆,邻接表形式,复杂度O(mlogn)//返回最小生成树的长度,传入图的大小n和邻接表list//可更改边权的类型,pre[]返回树的构造,用父结点表示,根节点(第一个)pre值为-1//必须保证图的连通的!#define MAXN 200#define inf 1000000000typedef double elem_t;struct edge_t{int from,to;elem_t len;edge_t* next;};#define _cp(a,b) ((a)<(b))struct heap{elem_t h[MAXN+1];int ind[MAXN+1],map[MAXN+1],n,p,c;void init(){n=0;}void ins(int i,elem_t e){for (p=++n;p>1&&_cp(e,h[p>>1]);h[map[ind[p]=ind[p>>1]]=p]=h[p>>1],p>>=1);h[map[ind[p]=i]=p]=e;}int del(int i,elem_t& e){i=map[i];if (i<1||i>n) return 0;for (e=h[p=i];p>1;h[map[ind[p]=ind[p>>1]]=p]=h[p>>1],p>>=1);for(c=2;c<n&&_cp(h[c+=(c<n-1&&_cp(h[c+1],h[c]))],h[n]);h[map[ind[p]=ind[c]]=p]=h[c],p=c,c<< =1);h[map[ind[p]=ind[n]]=p]=h[n];n--;return 1;}int delmin(int& i,elem_t& e){if (n<1) return 0;i=ind[1];for(e=h[p=1],c=2;c<n&&_cp(h[c+=(c<n-1&&_cp(h[c+1],h[c]))],h[n]);h[map[ind[p]=ind[c]]=p]=h[c ],p=c,c<<=1);h[map[ind[p]=ind[n]]=p]=h[n];n--;return 1;}};elem_t prim(int n,edge_t* list[],int* pre){heap h;elem_t min[MAXN],ret=0,e;edge_t* t;int v[MAXN],i;for (h.init(),i=0;i<n;i++)min[i]=(i?inf:0),v[i]=0,pre[i]=-1,h.ins(i,min[i]);while (h.delmin(i,e))for (v[i]=1,ret+=e,t=list[i];t;t=t->next)if (!v[t->to]&&t->len<min[t->to])pre[t->to]=t->from,h.del(t->to,e),h.ins(t->to,min[t->to]=t->len);return ret;}3.6 最小生成树(prim+mapped_heap正向表)//无向图最小生成树,prim算法+映射二分堆,正向表形式,复杂度O(mlogn)//返回最小生成树的长度,传入图的大小n和正向表list,buf//可更改边权的类型,pre[]返回树的构造,用父结点表示,根节点(第一个)pre值为-1//必须保证图的连通的!#define MAXN 200#define inf 1000000000typedef double elem_t;struct edge_t{int to;elem_t len;};#define _cp(a,b) ((a)<(b))struct heap{elem_t h[MAXN+1];int ind[MAXN+1],map[MAXN+1],n,p,c;void init(){n=0;}void ins(int i,elem_t e){for (p=++n;p>1&&_cp(e,h[p>>1]);h[map[ind[p]=ind[p>>1]]=p]=h[p>>1],p>>=1);h[map[ind[p]=i]=p]=e;}int del(int i,elem_t& e){i=map[i];if (i<1||i>n) return 0;for (e=h[p=i];p>1;h[map[ind[p]=ind[p>>1]]=p]=h[p>>1],p>>=1);for(c=2;c<n&&_cp(h[c+=(c<n-1&&_cp(h[c+1],h[c]))],h[n]);h[map[ind[p]=ind[c]]=p]=h[c],p=c,c<< =1);h[map[ind[p]=ind[n]]=p]=h[n];n--;return 1;}int delmin(int& i,elem_t& e){if (n<1) return 0;i=ind[1];for(e=h[p=1],c=2;c<n&&_cp(h[c+=(c<n-1&&_cp(h[c+1],h[c]))],h[n]);h[map[ind[p]=ind[c]]=p]=h[c ],p=c,c<<=1);h[map[ind[p]=ind[n]]=p]=h[n];n--;return 1;}};elem_t prim(int n,int* list,edge_t* buf,int* pre){heap h;elem_t min[MAXN],ret=0,e;int v[MAXN],i,j;for (h.init(),i=0;i<n;i++)min[i]=(i?inf:0),v[i]=0,pre[i]=-1,h.ins(i,min[i]);while (h.delmin(i,e))for (v[i]=1,ret+=e,j=list[i];j<list[i+1];j++)if (!v[buf[j].to]&&buf[j].len<min[buf[j].to])pre[buf[j].to]=i,h.del(buf[j].to,e),h.ins(buf[j].to,min[buf[j].to]=buf[j].len);return ret;}3.7 最小生成树(prim邻接阵)//无向图最小生成树,prim算法,邻接阵形式,复杂度O(n^2)//返回最小生成树的长度,传入图的大小n和邻接阵mat,不相邻点边权inf//可更改边权的类型,pre[]返回树的构造,用父结点表示,根节点(第一个)pre值为-1//必须保证图的连通的!#define MAXN 200#define inf 1000000000typedef double elem_t;elem_t prim(int n,elem_t mat[][MAXN],int* pre){elem_t min[MAXN],ret=0;int v[MAXN],i,j,k;for (i=0;i<n;i++)min[i]=inf,v[i]=0,pre[i]=-1;for (min[j=0]=0;j<n;j++){for (k=-1,i=0;i<n;i++)if (!v[i]&&(k==-1||min[i]<min[k]))k=i;for (v[k]=1,ret+=min[k],i=0;i<n;i++)if (!v[i]&&mat[k][i]<min[i])min[i]=mat[pre[i]=k][i];}return ret;}3.8 最小树形图(邻接阵)//多源最小树形图,edmonds算法,邻接阵形式,复杂度O(n^3)//返回最小生成树的长度,构造失败返回负值//传入图的大小n和邻接阵mat,不相邻点边权inf//可更改边权的类型,pre[]返回树的构造,用父结点表示//传入时pre[]数组清零,用-1标出源点#include <string.h>#define MAXN 120#define inf 1000000000typedef int elem_t;elem_t edmonds(int n,elem_t mat[][MAXN*2],int* pre){elem_t ret=0;int c[MAXN*2][MAXN*2],l[MAXN*2],p[MAXN*2],m=n,t,i,j,k;for (i=0;i<n;l[i]=i,i++);do{memset(c,0,sizeof(c)),memset(p,0xff,sizeof(p));for (t=m,i=0;i<m;c[i][i]=1,i++);for (i=0;i<t;i++)if (l[i]==i&&pre[i]!=-1){for (j=0;j<m;j++)if (l[j]==j&&i!=j&&mat[j][i]<inf&&(p[i]==-1||mat[j][i]<mat[p[i]][i]))p[i]=j;if ((pre[i]=p[i])==-1)return -1;if (c[i][p[i]]){for (j=0;j<=m;mat[j][m]=mat[m][j]=inf,j++);for (k=i;l[k]!=m;l[k]=m,k=p[k])for (j=0;j<m;j++)if (l[j]==j){if (mat[j][k]-mat[p[k]][k]<mat[j][m])mat[j][m]=mat[j][k]-mat[p[k]][k];if (mat[k][j]<mat[m][j])mat[m][j]=mat[k][j];}c[m][m]=1,l[m]=m,m++;}for (j=0;j<m;j++)if (c[i][j])for (k=p[i];k!=-1&&l[k]==k;c[k][j]=1,k=p[k]);}}while (t<m);for (;m-->n;pre[k]=pre[m])for (i=0;i<m;i++)if (l[i]==m){for (j=0;j<m;j++)if (pre[j]==m&&mat[i][j]==mat[m][j])pre[j]=i;if (mat[pre[m]][m]==mat[pre[m]][i]-mat[pre[i]][i])k=i;}for (i=0;i<n;i++)if (pre[i]!=-1)ret+=mat[pre[i]][i];return ret;}。
数学建模最小生成树例题
数学建模最小生成树例题（实用版）目录1.引言2.数学建模最小生成树的概念3.最小生成树例题解析4.例题解答过程5.总结正文1.引言数学建模是一种利用数学方法和工具来解决实际问题的方法，它涉及到许多数学领域，如概率论、统计学、微积分等。
在实际应用中，数学建模可以帮助我们更好地理解问题，找到问题的解决方案，甚至预测未来的发展趋势。
最小生成树是图论中的一个重要概念，它在运输、通信、计算机网络等领域有着广泛的应用。
本文将通过一个最小生成树的例题，介绍如何运用数学建模的方法解决实际问题。
2.数学建模最小生成树的概念最小生成树（Minimum Spanning Tree，简称 MST）是指在一个加权连通图中，一棵包含所有顶点且边权值之和最小的生成树。
生成树是指一个连通图的生成树是指保留图中所有的节点，但只保留足以保持这些节点连通的边的集合。
最小生成树是一种生成树，其中所有边的权值之和最小。
3.最小生成树例题解析例题：有一个电信公司需要在城市中建立一座基站，以使得城市中的所有区域都能被覆盖。
现在已知城市中的每个区域的人口数量和每个区域到其他区域的距离。
请问，电信公司应该选择哪些区域建立基站，使得所有区域的覆盖成本最低？4.例题解答过程我们可以将这个问题转化为一个最小生成树问题。
首先，将城市中的每个区域看作是一个节点，每个区域到其他区域的距离看作是节点之间的边，构建一个加权图。
然后，通过求解最小生成树问题，得到一个基站建设方案，使得所有区域的覆盖成本最低。
为了求解最小生成树问题，我们可以使用 Kruskal 算法或 Prim 算法。
这里我们以 Prim 算法为例，介绍如何求解最小生成树。
（1）将所有边按照权值从小到大排序。
（2）选取权值最小的边，将其两端节点加入生成树。
（3）删除已选择的边，重复步骤（2），直到生成树中有 n-1 条边（n 为节点数）。
通过以上步骤，我们可以得到一个基站建设方案，使得所有区域的覆盖成本最低。
最小生成树(Kruskal算法)
三、方案解决：
在本题中我们将采用 Kruskal 算法来构造最小生成树。 从题目所给赋权图中我们可以得到该图的邻接矩阵为：
⎡ 0 20 0 0 0 23 1 ⎤ ⎢20 0 15 0 0 0 4 ⎥ ⎢ ⎥ ⎢ 0 15 0 3 0 0 9 ⎥ ⎢ ⎥ G = ⎢ 0 0 3 0 17 0 16 ⎥ ⎢ 0 0 0 17 0 28 25⎥ ⎢ ⎥ ⎢ 23 0 0 0 28 0 36⎥ ⎢ 1 4 9 16 25 36 0 ⎥ ⎣ ⎦
-3-
6.选择造价第五小的序号为 5 的边，即 S 23 ，由于加入后边 S 23 ， S 27 ， S37 将构成回路，因此 舍弃该边 如图所示：
7.选择造价第六小的序号为 6 的边，即 S 47 ，由于加入后边 S34 ， S37 ， S 47 将构成回路，因此 舍弃该边 如图所示：
8.选择造价第七小的序号为 7 的边，即 S 45 ，加入 T 中，此时 T={{6},{ S17 ， S34 ， S 27 ， S37 ，
S 45 ， S16 }}，Cost=34+23=57
如图所示：
11.算法结束 此时，所有顶点已包含在树中，整棵最小生成树已经构造完成。即应该在城市{（1,7） ， （2,7） ， （3,7） ， （3,4） ， （4,5） ， （1,6）}之间建造通信道路，可使得城市间相互通信又造价费 用最小，此时可以得到其最小的费用为 57 万元
-7-
edges[k].end = j; edges[k].weight = G->arc[i][j].weight; k++; } } } sort(edges, G); for (i = 1; i <= G->arcnum; i++) { parent[i] = 0; } printf("最小生成树为:\n"); for (i = 1; i <= G->arcnum; i++)//核心部分 { n = Find(parent, edges[i].begin); m = Find(parent, edges[i].end); if (n != m) { parent[n] = m; printf("< %d, %d > %d\n", edges[i].begin, edges[i].end, edges[i].weight); Mincost+=edges[i].weight; } } printf("使各城市间能够通信的最小费用为：Mincost=%d\n",Mincost); } int Find(int *parent, int f) { while ( parent[f] > 0) { f = parent[f]; } return f; }
图最小生成树
是按逐个将顶点连通的方式来构造最
小生成树的。
10
从连通网络 N = { V, E }中的某一顶点 u0 出 发，选择与它关联的具有最小权值的边( u0, v)， 将其顶点加入到生成树的顶点集合U中。 以后每一步从一个顶点在 U 中，而另一个顶点不 在U中的各条边中选择权值最小的边(u, v),把该 边加入到生成树的边集TE中，把它的顶点加入到 集合 U 中。如此重复执行，直到网络中的所有顶 点都加入到生成树顶点集合U中为止。
for (i=0; i<G.vexnum; ++i)
// 建零入度顶点栈S
if (!indegree[i]) Push(S, i); // 入度为0者进栈 count = 0; // 对输出顶点计数
while (!StackEmpty(S)) { Pop(S, i); printf(i, G.vertices[i].data); ++count; // 输出i号顶点并计数 for (p=G.vertices[i].firstarc; p; p=p->nextarc) { k = p->adjvex; // 对i号顶点的每个邻接点的入度减1
23
由于AOV网中有些活动之间没有次序要求，它们在拓扑序列的 位置可以是任意的，因此拓扑排序的结果不唯一。
C1 C3 C4
对右图进行拓扑排序，可得一个拓扑序列： C1，C3，C2，C4，C7，C6，C5 也可得到另一个拓扑序列： C2，C7，C1，C3，C4，C5，C6
C7 C2
C6 C5
还可以得到其它的拓扑序列。学生按照任何一个拓扑序列都可 以完成所要求的全部课程学习。 在AOV网中不应该出现有向环。因为环的存在意味着某项活动 将以自己为先决条件，显然无法形成拓扑序列。 判定网中是否存在环的方法：对有向图构造其顶点的拓扑有序 序列，若网中所有顶点都出现在它的拓扑有序序列中，则该 AOV网中一定不存在环。
图论模型及其解答
各种图论模型及其解答摘要：本文用另一种思路重新组织《图论及其应用》相关知识。
首先，用通俗化语言阐述了如何对事物间联系的问题进行图论建模；接着从现实例子出发，给出各种典型图论模型，每种图论模型对应于图论一个重要内容；再者，介绍相关知识对上述提到的图论模型涉及的问题进行解答；最后，补充一些图论其他知识，包括图论分支、易混概念。
符号约定：Q(Question)表示对问题描述，M(Modeling)表示数学建模过程，A(Answer)表示原问题转化为何种图论问题。
一、引言图论是研究点、线间关系的一门学科，属于应用数学的一部分。
现实生活中，凡是涉及到事物间的关系，都可以抽象为图论模型。
点表示事物，连线表示事物间的联系。
整个求解过程如下：原问题——>图论建模——>运用图论相关理论求解——>转化为原问题的解整个过程关键在于图论建模，所谓图论建模，就是明确点表示什么，连线表示什么，原问题转化为图论中的什么问题。
存在以下两种情况：①若事物间联系是可逆的(比如双行道，朋友)，则抽象成无向图②若事物间联系是不可逆的(比如单行道，状态转化不可逆)，则抽象成有向图如果需要进一步刻画事物间的联系（比如城市间的距离），就给连线赋一个权值，从而抽象成赋值图。
综上，根据实际问题，可建模成下列图论模型的一种：无向赋权图、有向赋权图、无向非赋权图、有向非赋权图。
例1.宴会定理：任何一宴会中，一定存在两个人有相同的数量朋友M：点表示人，连线表示当且仅当该两个人是朋友A：问题转化为任何一个图一定存在两个顶点的度相等二、图论模型接下来介绍若干典型的图论模型，每种模型几乎对应于图论的一个重要内容，这些内容将在第三章进行讨论，也就给出了这些模型的解答思路。
2.1 偶图模型凡涉及两类事物间的联系（即只考虑两类事物间的联系，而不考虑同类事物间的联系），均可抽象成偶图模型。
作图时，将两类事物分成两行或者两列。
这类模型通常被包含在后续的模型中，但因许多现实问题可抽象成该模型，所以单列出来讨论。
图论论文
最小生成树——Prim算法1、算法问题的提出首先介绍生成树的概念连通图G=(V,E)是无向带权图，若一个子图G’是一棵包含G的所有顶点的树，则该子图G’称为G的生成树。
生成树是连通图的极小连通子图。
所谓极小是指：若在树中任意增加一条边，则将出现一个回路；若去掉一条边，将会使之变成非连通图。
生成树各边的权值总和称为生成树的权。
本次设计是求在图G中所有生成树中权值总和（费用/代价）最小的生成树，即最小生成树。
用两个例子进行实例演示。
2、Prim算法思想用哲学的观点来说，每个事物都有自己特有的性质，那么图的最小生成树也是不例外的。
按照生成树的定义，n 个顶点的连通网络的生成树有n 个顶点、n-1 条边。
（1）从树中某一个顶点V0开始，将V0到其他顶点的所有边当作候选边。
（2）重复以下步骤n-1次，使得其他n-1个顶点被并入到生成树中。
○1从候选边挑出权值最小的边输出，并将与该边另一端的相接的顶点V并入生成树中。
○2考察所有剩余顶点V i，如果(V,V i)的权值比lowcost[V i]小，则用（V,V i）的权值更新lowcost[V i]。
其中的vset[i]的值记录顶点V[i]顶点是否被选入最小生成树中，V[i]=0,表示为被选入，V[i]=1，表示已被选入。
用到辅助数组pre[]，记录当前所选入顶点的前驱结点，当并入前一个顶点时，剩下顶点到生成树的权值发生了改变时，就需要及时修改剩下顶点V[i]的前驱结点。
3、程序设计（1）所用数据结构，图的存储结构模块（nodetype.h）#define MAXSIZE 7#define INF 100typedef struct{int no;}VertexType; //顶点类型定义typedef struct{int edges[MAXSIZE][MAXSIZE]; //存入边的权值int n; //顶点数int e; //总的边数VertexType vex[MAXSIZE];}MGraph; //图的存储结构MGraph g;（2）主模块（main.cpp）#include#include"nodetype.h"#include"initiate.h"#include"prim.h"void prim(MGraph g,int v0,int &sum);int main(){int sum=0;int v0;initiate(g); //图的初始化printf("请输入起点编号：\n");scanf("%d",&v0);//输入起始节点prim(g,v0,sum); //调用prim算法，构成最小生成树printf("最小生成树的总代价为%d\n",sum);return 0;}（3）读取数据模块,图的初始化（initiate.h）void initiate(MGraph &g){int i,j,v0=0;printf("Please input the Sumnum of MGraph:\n");scanf("%d",&g.n);printf("依次输入各边权值（不相临接的边权值为100）!\n\n"); for(i=1;i<=g.n;i++){g.vex[i].no=i; //节点编号for(j=1;j<=g.n;j++){printf("边[%d][%d]的权值为：",i,j);//各边的权值scanf("%d",&g.edges[i][j]);printf("\n");}}}(4）运用贪心策略——Prim算法构造最小生成树（prim.h）void prim(MGraph g,int v0,int &sum){int lowcost[MAXSIZE],vset[MAXSIZE];int v,pre[MAXSIZE]; //pre[]存入前驱结点数组int i,j,k,min;v=v0; //初始起点for(i=1;i<=g.n;i++){lowcost[i]=g.edges[v0][i]; //lowcost[]的数组pre[i]=v0;vset[i]=0;}vset[v0]=1;sum=0;for(i=1;imin=INF;for(j=1;j<=g.n;j++){if(vset[j]==0&&lowcost[j]min=lowcost[j];k=j;}}vset[k]=1; //将此结点并入到所够造的生成树中v=k;if(min!=INF){printf("边的起点为：%d 终点为：%d 权值为%d\n",pre[v],v,min);sum+=min;}else{break;}for(j=1;j<=g.n;j++){//并入新结点后修改剩下的结点到生成树的权值if(vset[j]==0&&g.edges[v][j]lowcost[j]=g.edges[v][j];pre[j]=v; //并记其下全趋结点}}}}4、算法分析Prim算法的时间复杂度主要是在双重循环构造最小生成树的过程中，设图的顶点数为n，则双重循环的时间复杂度为O(n2)，在生成最小生成树的过程中，增加了两个数组，vset[]和lowcost[]数组，同时增加了一个前驱数组prey[]，用来记录所选顶点的全趋结点，故空间复杂度为O(3n)。
运筹学上机试题5-图论
四、图论1、求下图中从v1到v3最短路。
v 1v 3v 546从节点 1到节点3的最短路 *************************起点 终点 距离 ---- ---- ---- 1 2 1 2 3 6此问题的解为:7 2、最小生成树电信公司要在15个城市之间铺设光缆，这些城市的位置及相互之间的铺设光缆的费用如下图所示。
试求出一个连接在15个城市的铺设方案，使得总费用最小。
v 1v 2v 3v 4v 5v 6v 7v 8v 9v 10v 11v 12v 13v 14v 152241131456422323135134此问题的最小生成树如下：*************************起点终点距离---- ---- ----1 4 11 2 22 5 25 8 15 6 26 3 18 7 28 9 39 12 212 11 411 10 110 13 313 14 114 15 3此问题的解为:283、最短路问题例. 求下图中从v1到各点的最短路，并指出有哪些点是不可达到的。
vv7v8v4从节点 1到节点2的最短路*************************起点终点距离---- ---- ---- 1 2 4此问题的解为:41到3没有路1到4没有路从节点 1到节点5的最短路*************************起点终点距离 ---- ---- ---- 1 5 1此问题的解为:1从节点 1到节点6的最短路*************************起点终点距离 ---- ---- ---- 1 5 1 5 6 6此问题的解为:7从节点 1到节点7的最短路*************************起点终点距离 ---- ---- ---- 1 7 3此问题的解为:3从节点 1到节点8的最短路*************************起点终点距离 ---- ---- ---- 1 5 1 5 6 66 8 3此问题的解为:104、最短路问题有6个村庄，各村庄的距离如下图所示。
《最小生成树》PPT课件_OK
(2,5) 添加
{1,3},{4, 6},{2,5}
(3,6) 添加
{1,3,4, 6},{2,5}
(1,4) 放弃
因构成回路
(3,4) 放弃
因构成回路
(2,3) 添加
{1,3,4,5,6,2}
9
算法难点及解决方案
• 如何从所有边中选择代价最小的边：
– 用一个优先级队列来实现。将所有的边放入一个优先级 队列，边的优先级就是它的权值。权值越小，优先级越 高。
数据结构 Data Structure 第十三章 最小生成树
1
第13章 最小生成树
• 生成树与最小生成树 • Kruskal算法 • Prim算法 • 算法的正确性
2
生成树
• 生成树是无向连通图的极小连通子图。包含图的 所有 n 个结点，但只含图的 n-1 条边。在生成树 中添加一条边之后，必定会形成回路或环。
23
定理的证明
• 用反证法证明。 • 假定在图G = {V，E } 中，存在一棵不包括代价
• 在一个连通图中，一般边数总比结点数大，所以， Kruskal算法的时间复杂度是O(E|log|E|)。
14
第13章 最小生成树
• 生成树与最小生成树 • Kruskal算法 • Prim算法 • 算法的正确性
15
Prim算法
• 从顶点的角度出发。初始时，顶点集U为空，然 后逐个加入顶点，直到包含所有顶点。
• 如何判断加入一条边后会不会形成回路：
– 用并查集来实现。将一个连通分量表示为并查集中的一 个子集，检查一条边加入后会不会形成回路可以通过对 边的两个端点分别执行Find操作。如果两个Find的结果相 同，则表示两个端点已连通，加入这条边会形成回路， 否则将这条边加入生成树。添加边的操作就是一个Union 操作，将两个端点所属的子集归并起来，表示其中的所 有顶点都已连通。
最小生成树问题
2.1 最小生成树
树T(V,E)的性质：
E 树的边数等于其顶点数减“1”，即 V 1 ； 树的任意两个顶点之间恰有一条初级链相连接； 在树中任意去掉一条边后，便得到一个不连通的 图； 在树中任意两个顶点之间添加一条新边，所得新 图恰有一个初级圈。
例如，图 6.4.1 给出的 G1 和 G2 是树，但 G3 和 G4 则不是树。
44
44 69
结果显示于图
求最小生成树的 Prim 算法
Prim 算法的直观描述 假设 T0 是赋权图 G 的最小生成树。任选一 个顶点将其涂红，其余顶点为白点；在一个端 点为红色，另一个端点为白色的边中，找一条 权最小的边涂红，把该边的白端点也涂成红色； 如此，每次将一条边和一个顶点涂成红色，直 到所有顶点都成红色为止。最终的红色边便构 成最小生成树 T0 的边集合。
在求最小生成树的有效算法中，最著名的两个是 Kruskal（克罗斯克尔）算法和 Prim（普瑞姆）算法， 其迭代过程都是基于贪婪法来设计的。 1．求最小生成树的 Kruskal 算法
Kruskal 算法的直观描述 假设 T0 是赋权图 G 的最小生成树，T0 中的边和 顶点均涂成红色，初始时 G 中的边均为白色。 ① 将所有顶点涂成红色； ② 在白色边中挑选一条权值最小的边，使其与红 色边不形成圈，将该白色边涂红； ③ 重复②直到有 n1 条红色边，这 n1 条红色边 便构成最小生成树 T0 的边集合。
最小生成树算法
一个简单连通图只要不是树，其生成树就不唯 一，而且非常多。一般地，n 个顶点地完全图，其 不同地生成树个数为 nn2。因而，寻求一个给定赋 权图的最小生成树，一般是不能用穷举法的。例如， 30 个顶点的完全图有 3028个生成树，3028 有 42 位， 即使用最现代的计算机，在我们的有生之年也是无 法穷举的。所以，穷举法求最小生成树是无效的算 法，必须寻求有效的算法。
最小生成树（普里姆算法）
最⼩⽣成树（普⾥姆算法）：所谓⽣成树，就是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例题解释。
最小生成树
对于图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