离散数学--最小生成树实验报告

最小生成树实验报告最小生成树实验报告一、引言最小生成树是图论中的一个重要概念，它在实际问题中有着广泛的应用。

本次实验旨在通过编程实现最小生成树算法，并通过实验数据对算法进行分析和评估。

二、算法介绍最小生成树算法的目标是在给定的带权无向图中找到一棵生成树，使得树上所有边的权重之和最小。

本次实验我们选择了两种经典的最小生成树算法：Prim 算法和Kruskal算法。

1. Prim算法Prim算法是一种贪心算法，它从一个顶点开始，逐步扩展生成树的规模，直到包含所有顶点为止。

算法的具体步骤如下：（1）选择一个起始顶点，将其加入生成树中。

（2）从与生成树相邻的顶点中选择一个权重最小的边，将其加入生成树中。

（3）重复上述步骤，直到生成树包含所有顶点。

2. Kruskal算法Kruskal算法是一种基于并查集的贪心算法，它首先将图中的边按权重从小到大进行排序，然后逐个加入生成树中，直到生成树包含所有顶点为止。

算法的具体步骤如下：（1）将图中的边按权重从小到大进行排序。

（2）逐个加入边，如果该边的两个顶点不在同一个连通分量中，则将其加入生成树中。

（3）重复上述步骤，直到生成树包含所有顶点。

三、实验过程本次实验我们使用C++语言实现了Prim算法和Kruskal算法，并通过随机生成的图数据进行了测试。

1. Prim算法的实现我们首先使用邻接矩阵表示图的结构，然后利用优先队列来选择权重最小的边。

具体实现过程如下：（1）创建一个优先队列，用于存储生成树的候选边。

（2）选择一个起始顶点，将其加入生成树中。

（3）将与生成树相邻的顶点及其边加入优先队列。

（4）从优先队列中选择权重最小的边，将其加入生成树中，并更新优先队列。

（5）重复上述步骤，直到生成树包含所有顶点。

2. Kruskal算法的实现我们使用并查集来维护顶点之间的连通关系，通过排序后的边序列来逐个加入生成树中。

具体实现过程如下：（1）将图中的边按权重从小到大进行排序。

最小生成树（Minimum Spanning Tree）实验报告1. 实验目的本实验旨在通过实践掌握最小生成树算法的基本原理和实现方法。

最小生成树是图论中的一个重要概念，用于解决具有权重的连通图的最优路径问题。

通过本实验，我们将学习如何使用最小生成树算法找到一棵连接图的所有节点且总权重最小的树。

2. 实验原理最小生成树是一个连通图的一种生成树，它的所有边的权重之和最小。

最小生成树的求解算法有多种，其中两种常用的算法是 Prim 算法和 Kruskal 算法。

2.1 Prim 算法Prim 算法是一种贪心算法，从一个节点开始，逐步扩展最小生成树的边。

具体步骤如下： 1. 选择一个起始节点作为最小生成树的根节点。

2. 在当前最小生成树的所有节点中选择一个与该树相连接的权重最小的边，将其加入最小生成树。

3. 将该节点标记为已访问。

4. 重复步骤 2 和步骤 3，直到所有节点都被访问。

2.2 Kruskal 算法Kruskal 算法也是一种贪心算法，通过不断选择权重最小的边来构建最小生成树。

具体步骤如下： 1. 对所有边按照权重进行排序。

2. 依次选择权重最小的边，如果该边的两个端点不在同一个连通分量中，则将该边加入最小生成树，并将这两个端点合并到同一个连通分量中。

3. 重复步骤 2，直到所有节点都在同一个连通分量中，即最小生成树构建完成。

3. 实验步骤本实验将使用 Prim 算法和 Kruskal 算法分别求解给定图的最小生成树。

3.1 数据准备首先，我们需要准备一个具有权重的连通图作为实验数据。

假设该图有 n 个节点和 m 条边，我们可以使用邻接矩阵或邻接表来表示这个图。

3.2 Prim 算法求解最小生成树1.首先，选择一个起始节点作为最小生成树的根节点，并将该节点标记为已访问。

2.初始化一个空的最小生成树，用于存储最终的结果。

3.重复以下步骤，直到所有节点都被访问：1.在当前最小生成树的所有节点中选择一个与该树相连接的权重最小的边，将其加入最小生成树。

最小生成树算法实验报告【实验报告】最小生成树算法实验一、实验目的本次实验旨在研究最小生成树算法，通过对比不同的算法，并对实验结果进行分析，探索最小生成树算法的优劣势和适应场景。

二、实验过程1.算法介绍本次实验中我们将使用两种最小生成树算法：普里姆算法和克鲁斯卡尔算法。

- 普里姆算法（Prim算法）：从一个顶点开始，不断在剩下的顶点中选择到当前已有的最小生成树的距离最小的边，将该边的另一个顶点加入树中，直到所有的顶点都加入树中。

- 克鲁斯卡尔算法（Kruskal算法）：首先将所有边按照权值从小到大进行排序，然后以最小权值的边开始，依次选择权值最小且不会形成环路的边，直到找到n-1条边为止，其中n为顶点数。

2.实验步骤首先，我们使用Python语言实现了普里姆算法和克鲁斯卡尔算法。

然后，我们构造了一些测试用例，包括不同规模的图和不同权值分布的图。

最后，我们对实验结果进行对比分析。

三、实验结果1.测试用例设计我们设计了三个测试用例，分别为小规模图、中规模图和大规模图，具体如下：-小规模图：顶点数为5的图，权值随机分布。

-中规模图：顶点数为50的图，权值随机分布。

-大规模图：顶点数为100的图，权值随机分布。

2.实验结果分析我们的实验结果如下表所示：算法，小规模图，中规模图，大规模图:-------:，:------:，:------:，:------:普里姆算法，13，455，703从实验结果可以看出，对于小规模图和中规模图，普里姆算法的运行时间明显低于克鲁斯卡尔算法。

但是对于大规模图，克鲁斯卡尔算法的运行时间与普里姆算法的运行时间差距不大，甚至略小于普里姆算法。

这是因为克鲁斯卡尔算法中排序边的时间复杂度为O(ElogE)，而普里姆算法中筛选最小距离的边的时间复杂度为O(V^2)。

综上所述，普里姆算法适用于较小规模的图，而克鲁斯卡尔算法适用于较大规模的图。

四、实验总结本次实验研究了最小生成树算法，通过对比实验结果，我们发现不同算法在不同规模的图上的表现有所差异。

摘要最小生成树是数据结构中图的一种重要应用，在图中对于n个顶点的连通网可以建立许多不同的生成树，最小生成树就是在所有生成树中总的权值最小的生成树。

本课程设计是以邻接矩阵作为图的存储结构,分别采用Prim和Kruskal算法求最小生成树。

Kruskal算法和Prim算法是求最小生成树的常用算法它们分别适用于稠密图和稀疏图。

最小生成树的应用非常的广，如矿井通风设计和改造最优化方面以及如何搭建最短的网络线缆, 构建造价最低的通讯网络等等一系列的应用。

关键词：最小生成树，邻接矩阵，Kruskal算法，Prim算法目录一、引言 (3)二、设计目的与任务 (4)2.1课程设计目的 (4)2.2课程设计的任务 (4)三、设计方案 (4)3.1需求分析 (4)3.2数据结构分析 (4)3.2.1抽象数据类型(ADT)如下 (4)3.2.2基本操作 (5)3.2.3存储结构 (5)3.3最小生成树的算法分析 (7)3.3.1主函数模块代码......................... 错误!未定义书签。

3.3.2邻接矩阵定义模块代码 (7)3.3.3创建链接矩阵模块代码 (7)3.3.4最小生成树Prim算法及代价模块代码...... 错误!未定义书签。

3.3.5最小生成树kruskal算法及代价模块代码 (8)四、调试分析与体会 (9)五、运行结果 (10)六、结论 (16)七、参考文献 (16)一、引言《数据结构》是计算机科学与技术专业和信息管理与信息系统专业的必修课之一，是一门综合性的专业基础课。

本课程较系统地介绍了软件设计中常用的数据结构以及相应的实现算法，如线性表、栈、队列、树和二叉树，图、检索和排序等，并对性能进行分析和比较，内容非常丰富。

本课程设计我们要解决的问题是图最小生成树问题。

要用到图的先相关数据结构和求最小生成树的两种数据结构算法普里姆算法和克鲁斯卡尔算法，以及储存图的边和点的邻接矩阵。

实验5 最小生成树算法的设计与实现一、实验目的1、根据算法设计需要, 掌握连通图的灵活表示方法；2、掌握最小生成树算法，如Prim、Kruskal算法；3、基本掌握贪心算法的一般设计方法；4、进一步掌握集合的表示与操作算法的应用。

二、实验内容1、认真阅读算法设计教材和数据结构教材内容, 熟习连通图的不同表示方法和最小生成树算法；2、设计Kruskal算法实验程序。

有n个城市可以用（n-1）条路将它们连通，求最小总路程的和。

设计测试问题,修改并调试程序, 输出最小生成树的各条边, 直至正确为止。

三、Kruskal算法的原理方法边权排序:1 3 14 6 23 6 41 4 52 3 53 4 52 5 61 2 63 5 65 6 61. 初始化时：属于最小生成树的顶点U={}不属于最小生成树的顶点V={1，2，3，4，5，6}2. 根据边权排序，选出还没有连接并且权最小的边（1 3 1），属于最小生成树的顶点U={1，3}，不属于最小生成树的顶点V={2,4,5,6}3. 根据边权排序，选出还没有连接并且权最小的边（4 6 2），属于最小生成树的顶点U={{1，3}，{4，6}}（还没有合在一起，有两颗子树），不属于最小生成树的顶点V={2,5}4. 根据边权排序，选出还没有连接并且权最小的边（3 6 4），属于最小生成树的顶点U={1，3，4，6}（合在一起），不属于最小生成树的顶点V={2,5}5. 根据边权排序，选出还没有连接并且权最小的边（3 6 4），属于最小生成树的顶点U={1，2，3，4，6},，不属于最小生成树的顶点V={5}6. 根据边权排序，选出还没有连接并且权最小的边（3 6 4），属于最小生成树的顶点U={1，2，3，4，5，6}此时，最小生成树已完成四、实验程序的功能模块功能模块：bool cmp(Edge a,Edge b)； //定义比较方法x)；//在并查集森林中找到x的祖先int g etfa(intint s ame(int x,int y)； //判断祖先是否是同一个，即是否联通 void merge(int x,int y); //合并子树，即联通两子树sort(e+1,e+m+1,cmp); //对边按边权进行升序排序详细代码：#include <iostream>#include <cstdio>#include <cstring>#include <algorithm>#define M AXN_E 100000#define M AXN_V 100000using namespace std;struct Edge{int f m,to,dist;//边的起始顶点，边的到达顶点，边权}e[MAXN_E];int f a[MAXN_V],n,m; //顶点数组，顶点总数，边总数 //定义比较，只是边权比较bool cmp(Edge a,Edge b){return a.dist < b.dist;}//查找x的祖先是在并查集森林中找到x的祖先x){//getfaint g etfa(intreturn fa[x];if(fa[x]==x)else r eturn fa[x] = getfa(fa[x]);}//判断祖先是否是同一个，即是否联通int s ame(int x,int y){return getfa(x)==getfa(y);}//合并两棵树void merge(int x,int y){int f ax=getfa(x),fay=getfa(y);fa[fax]=fay;}int m ain(){int i;cout<<"请输入顶点数目和边数目："<<endl;cin>>n>>m;//n为点数，m为边数//输出顶点信息cout<<"各个顶点值依次为："<<endl;for(i=0;i<n;i++){fa[i]=i;if(i!=0)cout<<fa[i]<<" ";}cout<<endl;cout<<"请输入边的信息（例子：1 4 5 从顶点1到顶点4的边权为5）"<<endl;for(i=1;i<=m;i++)用边集数组存放边，方便排序和调用 cin>>e[i].fm>>e[i].to>>e[i].dist;//sort(e+1,e+m+1,cmp); //对边按边权进行升序排序表示目前的点共存在于多少个集合中，初始情况是每 int r st=n,ans=0;//rst个点都在不同的集合中for(i=1;i<=m && rst>1;i++){int x=e[i].fm,y=e[i].to;函数是查询两个点是否在同一集合中 if(same(x,y))continue;//sameelse{函数用来将两个点合并到同一集合中 merge(x,y);//mergerst--;//每次将两个不同集合中的点合并，都将使rst值减1这条边是最小生成树中的边，将答案加上边权 ans+=e[i].dist;//}}cout<<ans;return 0;}五、测试数据和相应的最小生成树Input:6 101 2 61 3 11 4 52 3 52 5 63 4 53 5 63 6 44 6 25 6 6Putout:18生成树为：七、思考题1、微软面试题一个大院子里住了50户人家，每家都养了一条狗，有一天他们接到通知说院子里有狗生病了，并要求所有主人在发现自己家狗生病的当天就要把狗枪杀掉。

离散数学大作业——编程实现最小生成树学院：电子工程学院班级：021051学号：*********名：***一、最小生成树概念：设G=(V,E)是无向连通带权图，即一个网络。

E中每条边(v,w)的权为c[v,w]。

所有生成树G’上各边权的总和最小的生成树称为G的最小生成树。

二、prim算法（贪心思想）设图G =（V，E），其生成树的顶点集合为U。

1.把v0放入U。

2.在所有u∈U，v∈V-U的边(u，v)∈E中找一条最小权值的边，加入生成树。

3.把2找到的边的v加入U集合。

如果U集合已有n个元素，则结束，否则继续执行2其算法的时间复杂度为O(n^2)三、程序源代码# include<stdio.h># include<malloc.h># define m 6# define n 11 typedef struct {int i,tag;char s;}vertice;typedef struct {int a,b,tag;int weight;}edge;vertice v[m];edge e[n];void inititate();void sort();void chuli();int biaoji( edge *s); void print();void main() {inititate();sort();chuli();print();}void inititate() {int i;printf("输入图的%d个顶点:\n",m);for(i=0;i<m;i++) {v[i].i=i+1;v[i].tag=0;scanf("%c",&v[i].s);getchar();}printf("\n输入%d条边的两端顶点及权：\n",n);for(i=0;i<n;i++) {scanf("%d %d %d",&e[i].a,&e[i].b,&e[i].weight);e[i].tag=0;}}int biaoji( edge *s) {int i,j;i=s->a;j=s->b;if(v[i].tag==0 || v[j].tag==0) {v[i].tag=1;v[i].tag=1;s->tag=1;return 1;}return 0;}void print() {int i,j=0;printf("\n最小生成树的边为：\n");for(i=0;i<n&&j<m-1;i++)if(e[i].tag==1) {printf("<%d-%d> ",e[i].a,e[i].b);j++;}printf("\n\n");}void sort() {edge s;int i,j;for(i=0;i<n-1;i++) {for(j=i+1;j<n;j++) {if(e[i].weight>e[j].weight) {s=e[i];e[i]=e[j];e[j]=s;}}}}void chuli() {int i,j=0;edge *s;for(i=0;i<n&&j<m;i++) {s=&e[i];if(biaoji(s)==1)j++;}}四、实验结果输入图的6个顶点:1 2 3 4 5 6输入11条边的权及两端顶点：1 2 11 4 61 6 91 3 112 3 22 4 33 5 83 6 74 5 104 6 45 6 5最小生成树的边为：<1-2> <2-3> <2-4> <4-6> <5-6> Press any key to continue。

数据结构实验报告-最小生成树（精选5篇）第一篇：数据结构实验报告-最小生成树电子科技大学实验报告学生姓名：XXX 学号：20***指导教师：刘峤实验地点：信软楼306实验时间：5月17日一、实验室名称：软件实验室二、实验项目名称：数据结构与算法—图三、实验学时：4四、实验原理：Kruskal 算法是一种按照图中边的权值递增的顺序构造最小生成树的方法。

其基本思想是：设无向连通网为G＝（V，E），令G 的最小生成树为T，其初态为T＝（V，{}），即开始时，最小生成树T 由图G 中的n 个顶点构成，顶点之间没有一条边，这样T 中各顶点各自构成一个连通分量。

然后，按照边的权值由小到大的顺序，考察G 的边集E 中的各条边。

若被考察的边的两个顶点属于T 的两个不同的连通分量，则将此边作为最小生成树的边加入到T 中，同时把两个连通分量连接为一个连通分量；若被考察边的两个顶点属于同一个连通分量，则舍去此边，以免造成回路，如此下去，当T 中的连通分量个数为1 时，此连通分量便为G 的一棵最小生成树。

如教材153页的图4.21(a)所示，按照Kruskal 方法构造最小生成树的过程如图4.21 所示。

在构造过程中，按照网中边的权值由小到大的顺序，不断选取当前未被选取的边集中权值最小的边。

依据生成树的概念，n 个结点的生成树，有n－1 条边，故反复上述过程，直到选取了n－1 条边为止，就构成了一棵最小生成树。

五、实验目的：本实验通过实现最小生成树的算法，使学生理解图的数据结构存储表示，并能理解最小生成树Kruskal 算法。

通过练习，加强对算法的理解，提高编程能力。

六、实验内容：（1）假定每对顶点表示图的一条边，每条边对应一个权值；（2）输入每条边的顶点和权值；（3）输入每条边后，计算出最小生成树；（4）打印最小生成树边的顶点及权值。

七、实验器材（设备、元器件）：八、数据结构及程序#include #include #include typedefstruct {intvex;intgno;}TVex,*TpVex;typedefstruct {intvhead, vtail;intwght;intflag;}TEdge,*TpEdge;typedef struct{TpVex VexList;TpEdge EdgeList;int nvex, nedge;}TGraph, *TpGraph;void begin(TpGraph G){ int i;for(i=1;i<=G->nvex;i++){G->VexList[i-1].gno=i;G->EdgeList[i-1].flag=0;} } int findmin(TpGraph G){ int i,j;int minwght=G->EdgeList[0].wght;for(i=0,j=-1;inedge;i++){ PC机一台，装有C/C++语言集成开发环境。

大连民族学院计算机科学与工程学院实验报告实验题目：最小生成树的Kruskal算法课程名称：离散数学实验类型：□演示性□验证性□操作性■设计性□综合性专业：软件工程班级：111学生姓名：xx学号：xx实验日期：2012年12月6-28日实验地点：金石滩校区机房201 实验学时：10学时实验成绩：指导教师：焉德军姜楠2012年12月28 日[实验原理]设所给定无向连通加权图具有n个结点，m条边，首先，将各条边的权按从小到大的顺序排序。

然后依次将这些边按所给图的结构放到生成树中去。

如果在放置某一条边时，使得生成树形成回路，则删除这条边。

这样，直至生成树具有n-1条边时，我们所得到的就是一棵最小生成树。

[实验内容]给定无向连通加权图，编程设计求出其一棵最小生成树。

[实验目的]通过算法设计并编程实现求出给定无向连通加权图的一棵最小生成树，加深学生对求最小生成树的Kruskal算法的理解。

[实验步骤]（1）边依小到大顺序得l1，l2，…，lm。

（2）置初值：⇒∅S，0⇒i，1⇒j。

（3）若i=n-1，则转（6）。

（4）若生成树边集S并入一条新的边lj之后产生的回路，则j+1⇒j，并转（4）。

（5）否则，i+1⇒i；l j⇒S（i）；j+1⇒j，转（3）。

（6）输出最小生成树S。

（7）结束。

具体程序的C++实现如下：#include<iostream>using namespace std;const int MaxVertex = 20;const int MaxEdge = 100;const int MaxSize = 100;struct EdgeType{int from;int to;int weight;};struct EdgeGraph{char vertex[MaxVertex];EdgeType edge[MaxEdge];int vertexNum;int edgeNum;};int FindRoot(int parent[], int v);void InputInfo();void Kruskal(EdgeGraph G){int vex1,vex2,f,t;int i,num;int parent[MaxVertex];for(i=0; i<G.vertexNum; i++){parent[i] = -1;}for(num =0,i=0; i<G.edgeNum; i++){vex1 = FindRoot(parent, G.edge[i].from);vex2 = FindRoot(parent, G.edge[i].to);if(vex1 != vex2){cout << "(" << G.edge[i].from << "," << G.edge[i].to << ")" << endl;f = G.edge[i].from;t = G.edge[i].to;cout << "(" << G.vertex[f] << "," << G.vertex[t] << ")" << " Weight: " << G.edge[i].weight << endl;cout << endl;parent[vex2] = vex1;num++;if(num == G.vertexNum-1) return;}}return;}int FindRoot(int parent[], int v){int t;t = v;if(parent[t] > -1){t = parent[t];}return t;}void InputInfo(){EdgeGraph G;cout << "Please input vertexNum , edgeNum: " << endl;cin >> G.vertexNum >> G.edgeNum;cout << "Please input the information of edges:" << endl;for(int i=0; i<G.vertexNum; i++){cin >> G.vertex[i];}cout << "Please input this edge attaches two vertices subscript and its weight" << endl;for(int j=0; j<G.edgeNum; j++){cin >> G.edge[j].from >> G.edge[j].to >> G.edge[j].weight;}Kruskal(G);}int main(){InputInfo();system("pause");return 0;}实验过程中遇到的问题及解决过程比如不知道如何存储边集数组，以及比知道如何声明一些变量，函数和怎样去调用Kruskal函数……解决：通过设置结构体EdgeType与结构体EdgeGraph的联合来存储边集，因为在刚开始我在主函数中用EdgeGraph声明变量G，来作为形参去调用Kruskal(G)，编译时就会警告未被初始化的G，的程序出错，后来我将Kruskal(G)在InputInfo() 中调用，因为InputInfo()函数中声明了变量G，并使得G初始化，从而是的程序能正常运行。

离散数学实验报告姓名：学号：班级:实验地点：实验时间：Word文档1实验目的和要求运用最小生成树思想和求最小生成树程序解决实际问题。

实际问题描述如下：八口海上油井相互间距离如下表，其中1号井离海岸最近，为5km。

问从海岸经1 号井铺设油管把各井连接起来，怎样连油管长度最短（为便于检修，油管只准在油井处分叉）？「到 2 3 4 5 6 7 81 1.3 2.1 0.9 0.7 1.8 2.0 1.820.9 1.8 1.2 2.8 2.3 1.13 2.6 1.7 2.5 1.9 1.040.7 1.6 1.5 0.950.9 1.1 0.860.6 1.070.52实验环境和工具实验环境：Windows 7旗舰版工具：Dev-C++ 5.8.33实验过程3.1算法流程1Word i=0;j=0;惠档exnum=8;结束3.2程序核心代码〃油管铺设问题Prim 算法实现#include <iostream> #include<iomanip> using namespace std; #define MAXV 10#define INF 32767 //INF 表示8 typedef int InfoType; typedef struct{int no; InfoType info; } VertexType;typedef struct{〃图的定义float edges[MAXV][MAXV]; 〃邻接矩阵 int vexnum;//顶点数 VertexType vexs[MAXV]; //存放顶点信息 } MGraph;//图的邻接矩阵类型〃顶点编号 //顶点其他信息 〃顶点类型Word文档/*输出邻接矩阵g*/void DispMat(MGraph g){int i,j;for (i=0;i<g.vexnum;i + +){for (j=0;j<g.vexnum;j + +)if (g.edges[i][j] = = INF)cout<<setw⑹<<“8"；elsecout<<setw(6)<<g.edges[i][j];cout<<endl;))void prim(MGraph g,int v){ //从顶点V0 出发，按Prim 算法构造G的最小生成树//输出最小生成树的每条边及其权值float Vlength[MAXV];int i, j, k;int cloest[MAXV];float min;float sum = 0.0;Word文档for(i=0;i<g.vexnum;i ++){Vlength[i]=g.edges[v][i];cloest[i]=v;)for(i = 1;i<g.vexnum;i + +){min = INF; //min为其中最大的一条边二MAXVfor(j=0;j<g.vexnum;j + +){〃找n-1 条边if(Vlength[j]!=0&&Vlength[j]<min){min=Vlength[j];k=j;))cout<<" 连接油<”<<cloest[k] + 1<<”,”<<k+1<<">"<<“ 长度为:"<<min<<endl;sum + = min;Vlength[k]=0;Vlength[cloest[k]]=0;for(j=0;j<g.vexnum;j + +){ 〃选择当前代价最小的边if(g.edges[k][j]!=0&&g.edges[k][j]<Vlength[j]){Vlength[j]=g.edges[k][j];cloest[j]=k;Word文档)cout<<"管道总长度为："<<sum<<endl;)int main()(int i,j,u=3;MGraph g;float A[MAXV][10];g.vexnum=8;for (i=0;i<g.vexnum;i + +)for (j=0;j<g.vexnum;j + +)A[i][j] = INF;A[0][1] = 1.3; A[0][2]=2.1; A[0][3]=0.9;A[0][4]=0.7; A[0][5] = 1.8; A[0][6]=2.0;A[0][7] = 1.8; A[1][2]=0.9; A[1][3] = 1.8;A[1][4] = 1.2; A[1][5]=2.8; A[1][6]=2.3;A[1][7] = 1.1; A[2][3]=2.6; A[2][4] = 1.7;A[2][5]=2.5; A[2][6] = 1.9; A[2][7] = 1.0;A[3][4]=0.7; A[3][5] = 1.6; A[3][6] = 1.5;A[3][7]=0.9; A[4][5]=0.9; A[4][6] = 1.1;Word文档A[4][7]=0.8; A[5][6]=0.6; A[5][7] = 1.0;A[6][7]=0.5;for (i=0;i<g.vexnum;i + +)for (j=0;j<g.vexnum;j + +)A[j][i]=A[i][j];for (i=0;i<g.vexnum;i + +) /*建立图的邻接矩阵*/ for (j=0;j<g.vexnum;j + +)g.edges[i][j]=A[i][j];cout<<endl;cout<<”各油井间距离:\n";DispMat(g);cout<<endl;cout<<"最优铺设方案:\n";prim(g,0);cout<<endl;return 0;)3.3运行结果Word文档exited after O.06836 seconds 3.4 运行结果分析程序实现了输出需要铺设管道的油井编号，并给出了每条管道长度以及总长度，基 本实现了题目要求。

离散数学实验报告姓名：学号：班级：实验地点：实验时间：1实验目的和要求运用最小生成树思想和求最小生成树程序解决实际问题。

实际问题描述如下：八口海上油井相互间距离如下表，其中1号井离海岸最近，为5km。

问从海岸经1号井铺设油管把各井连接起来，怎样连油管长度最短（为便于检修，油管只准在油井处分叉）？2实验环境和工具实验环境：Windows 7 旗舰版工具：Dev-C++ 5.8.33实验过程3.1算法流程图3.2程序核心代码//油管铺设问题 Prim算法实现#include <iostream>#include<iomanip>using namespace std;#define MAXV 10#define INF 32767 //INF表示∞typedef int InfoType;typedef struct{int no; //顶点编号InfoType info; //顶点其他信息} VertexType; //顶点类型typedef struct{ //图的定义float edges[MAXV][MAXV]; //邻接矩阵int vexnum; //顶点数VertexType vexs[MAXV]; //存放顶点信息} MGraph; //图的邻接矩阵类型/*输出邻接矩阵g*/void DispMat(MGraph g){int i,j;for (j=0;j<g.vexnum;j++)if (g.edges[i][j]==INF)cout<<setw(6)<<"∞";elsecout<<setw(6)<<g.edges[i][j];cout<<endl;}}void prim(MGraph g,int v){ //从顶点V0出发，按Prim算法构造G的最小生成树//输出最小生成树的每条边及其权值float Vlength[MAXV];int i, j, k;int cloest[MAXV];float min;float sum = 0.0;for(i=0;i<g.vexnum;i++){Vlength[i]=g.edges[v][i];cloest[i]=v;}min=INF; //min为其中最大的一条边=MAXVfor(j=0;j<g.vexnum;j++){ //找n-1条边if(Vlength[j]!=0&&Vlength[j]<min){min=Vlength[j];k=j;}}cout<<"连接油井<"<<cloest[k]+1<<","<<k+1<<">"<<"长度为:"<<min<<endl;sum+=min;Vlength[k]=0;Vlength[cloest[k]]=0;for(j=0;j<g.vexnum;j++){ //选择当前代价最小的边if(g.edges[k][j]!=0&&g.edges[k][j]<Vlength[j]){ Vlength[j]=g.edges[k][j];cloest[j]=k;}}}cout<<"管道总长度为："<<sum<<endl;}int main(){int i,j,u=3;MGraph g;float A[MAXV][10];g.vexnum=8;for (i=0;i<g.vexnum;i++)for (j=0;j<g.vexnum;j++)A[i][j]=INF;A[0][1]=1.3; A[0][2]=2.1; A[0][3]=0.9;A[0][4]=0.7; A[0][5]=1.8; A[0][6]=2.0;A[0][7]=1.8; A[1][2]=0.9; A[1][3]=1.8;A[1][4]=1.2; A[1][5]=2.8; A[1][6]=2.3;A[1][7]=1.1; A[2][3]=2.6; A[2][4]=1.7;A[2][5]=2.5; A[2][6]=1.9; A[2][7]=1.0;A[3][4]=0.7; A[3][5]=1.6; A[3][6]=1.5;A[3][7]=0.9; A[4][5]=0.9; A[4][6]=1.1;A[4][7]=0.8; A[5][6]=0.6; A[5][7]=1.0;A[6][7]=0.5;for (i=0;i<g.vexnum;i++)for (j=0;j<g.vexnum;j++)A[j][i]=A[i][j];for (i=0;i<g.vexnum;i++) /*建立图的邻接矩阵*/ for (j=0;j<g.vexnum;j++)g.edges[i][j]=A[i][j];cout<<endl;cout<<"各油井间距离:\n";DispMat(g);cout<<endl;cout<<"最优铺设方案:\n";prim(g,0);cout<<endl;return 0;}3.3运行结果3.4运行结果分析程序实现了输出需要铺设管道的油井编号，并给出了每条管道长度以及总长度，基本实现了题目要求。