实验 1 贪心算法实现最小生成树
最小生成树 实验报告
最小生成树实验报告最小生成树实验报告一、引言最小生成树是图论中的一个重要概念，它在实际问题中有着广泛的应用。
本次实验旨在通过编程实现最小生成树算法，并通过实验数据对算法进行分析和评估。
二、算法介绍最小生成树算法的目标是在给定的带权无向图中找到一棵生成树，使得树上所有边的权重之和最小。
本次实验我们选择了两种经典的最小生成树算法：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）将图中的边按权重从小到大进行排序。
Boruvka算法求最小生成树
Boruvka算法求最⼩⽣成树学习了⼀个新的最⼩⽣成树的算法，Boruvka（虽然我不知道怎么读）。
算法思想也是贪⼼，类似于Kruskal。
⼤致是这样的，我们维护图中所有连通块，然后遍历所有的点和边，找到每⼀个连通块和其他连通块相连的最⼩的⼀条边，然后把连通块合并起来，重复这个操作，直到剩下⼀整个连通块，最开始状态是每个点是⼀个单独的连通块。
复杂度是(n+m)longn，因为每次都会合并两个连通块，整个程序进⾏log次操作就会完成，每次操作的复杂度是n+m的。
代码⾮常好理解，我⽤的并查集实现，（然⽽并查集我没有⽤按秩合并，都是细节）。
——by VANE#include<bits/stdc++.h>using namespace std;const int N=5005;const int M=200005;int pre[M<<1],other[M<<1],last[N],l,len[M<<1];int n,m;void add(int x,int y,int z){++l;pre[l]=last[x];last[x]=l;other[l]=y;len[l]=z;}int f[N],mn[2][N];int getfa(int x){return x==f[x]?x:f[x]=getfa(f[x]);}void merge(int x,int y){int fx=getfa(x),fy=getfa(y);f[fx]=fy;}int main(){scanf("%d%d",&n,&m);for(int i=1;i<=n;++i) f[i]=i;for(int i=1;i<=m;++i){int x,y,z;scanf("%d%d%d",&x,&y,&z);add(x,y,z);add(y,x,z);}int ans=0;while(1){memset(mn[0],127,sizeof mn[0]);bool flag=0;for(int i=1;i<=n;++i){for(int p=last[i];p;p=pre[p]){if(getfa(i)!=getfa(other[p]))if(mn[0][getfa(i)]>len[p]){mn[0][getfa(i)]=len[p];mn[1][getfa(i)]=getfa(other[p]);}}}for(int i=1;i<=n;++i){if(mn[0][i]!=mn[0][0]&&getfa(i)!=getfa(mn[1][i])){flag=1;ans+=mn[0][i];merge(i,mn[1][i]);}}if(!flag) break;}for(int i=1;i<n;++i)if(getfa(i)!=getfa(i+1)){puts("orz");return0;}cout<<ans;}。
贪心算法Kruskal 算法
Kruskal 算法假设给定一个加权连通图G，G的边集合为E，顶点个数为n，要求其一棵最小生成树T。
Kruskal 算法的粗略描述：假设T中的边和顶点均涂成红色，其余边为白色。
开始时G中的边均为白色。
1）将所有顶点涂成红色；2）在白色边中，挑选一条权最小的边，使其与红色边不形成圈，将该白色边涂红；3）重复2）直到有n-1条红色边，这n-1条红色边便构成最小生成树T的边集合。
注意到在算法执行过程中，红色顶点和红色边会形成一个或多个连通分支，它们都是G的子树。
一条边与红色边形成圈当且仅当这条边的两个端点属于同一个子树。
因此判定一条边是否与红色边形成圈，只需判断这条边的两端点是否属于同一个子树。
上述判断可以如此实现：给每个子树一个不同的编号，对每一个顶点引入一个标记t，表示这个顶点所在的子树编号。
当加入一条红色边，就会使该边两端点所在的两个子树连接起来，成为一个子树，从而两个子树中的顶点标记要改变成一样。
综上，可将Kruskal算法细化使其更容易计算机实现。
代码://Kruskal#include "stdio.h"#define maxver 10#define maxright 100int G[maxver][maxver],record=0,touched[maxver][maxver];int circle=0;int FindCircle(int,int,int,int);void main(){int path[maxver][2],used[maxver][maxver];int i,j,k,t,min=maxright,exsit=0;int v1,v2,num,temp,status=0;restart:printf("Please enter the number of vertex(s) in the graph:\n");scanf("%d",&num);if(num>maxver||num<0){printf("Error!Please reinput!\n");goto restart;}for(j=0;j<num;j++)for(k=0;k<num;k++){if(j==k){G[j][k]=maxright;used[j][k]=1;}elseif(j<k){re:printf("Please input the right between vertex %d and vertex %d,if no edge exists please input -1:\n",j+1,k+1);scanf("%d",&temp);if(temp>=maxright||temp<-1){printf("Invalid input!\n");goto re;}if(temp==-1)temp=maxright;G[j][k]=G[k][j]=temp;used[j][k]=used[k][j]=0;touched[j][k]=touched[k][j]=0;}}for(j=0;j<num;j++){path[j][0]=0;path[j][1]=0;}for(j=0;j<num;j++){status=0;for(k=0;k<num;k++)if(G[j][k]<maxright){status=1;break;}if(status==0)break;}for(i=0;i<num-1&&status;i++){for(j=0;j<num;j++)for(k=0;k<num;k++)if(G[j][k]<min&&!used[j][k]){v1=j;v2=k;min=G[j][k];}if(!used[v1][v2])used[v2][v1]=1;touched[v1][v2]=1;touched[v2][v1]=1;path[i][0]=v1;path[i][1]=v2;for(t=0;t<record;t++)FindCircle(path[t][0],path[t][0],num,path[t][0]);if(circle){/*if a circle exsits,roll back*/circle=0;i--;exsit=0;touched[v1][v2]=0;touched[v2][v1]=0;min=maxright;}else{record++;min=maxright;}}}if(!status)printf("We cannot deal with it because the graph is not connected!\n"); else{for(i=0;i<num-1;i++)printf("Path %d:vertex %d to vertex %d\n",i+1,path[i][0]+1,path[i][1]+1); }}int FindCircle(int start,int begin,int times,int pre){ /* to judge whether a circle is produced*/int i;for(i=0;i<times;i++)if(touched[begin][i]==1){if(i==start&&pre!=start){circle=1;return 1;break;}elseif(pre!=i)FindCircle(start,i,times,begin);else continue; }return 1; }。
算法课设实验报告(3篇)
第1篇一、实验背景与目的随着计算机技术的飞速发展，算法在计算机科学中扮演着至关重要的角色。
为了加深对算法设计与分析的理解，提高实际应用能力，本实验课程设计旨在通过实际操作，让学生掌握算法设计与分析的基本方法，学会运用所学知识解决实际问题。
二、实验内容与步骤本次实验共分为三个部分，分别为排序算法、贪心算法和动态规划算法的设计与实现。
1. 排序算法（1）实验目的：熟悉常见的排序算法，理解其原理，比较其优缺点，并实现至少三种排序算法。
（2）实验内容：- 实现冒泡排序、快速排序和归并排序三种算法。
- 对每种算法进行时间复杂度和空间复杂度的分析。
- 编写测试程序，对算法进行性能测试，比较不同算法的优劣。
（3）实验步骤：- 分析冒泡排序、快速排序和归并排序的原理。
- 编写三种排序算法的代码。
- 分析代码的时间复杂度和空间复杂度。
- 编写测试程序，生成随机测试数据，测试三种算法的性能。
- 比较三种算法的运行时间和内存占用。
2. 贪心算法（1）实验目的：理解贪心算法的基本思想，掌握贪心算法的解题步骤，并实现一个贪心算法问题。
（2）实验内容：- 实现一个贪心算法问题，如活动选择问题。
- 分析贪心算法的正确性，并证明其最优性。
（3）实验步骤：- 分析活动选择问题的贪心策略。
- 编写贪心算法的代码。
- 分析贪心算法的正确性，并证明其最优性。
- 编写测试程序，验证贪心算法的正确性。
3. 动态规划算法（1）实验目的：理解动态规划算法的基本思想，掌握动态规划算法的解题步骤，并实现一个动态规划算法问题。
（2）实验内容：- 实现一个动态规划算法问题，如背包问题。
- 分析动态规划算法的正确性，并证明其最优性。
（3）实验步骤：- 分析背包问题的动态规划策略。
- 编写动态规划算法的代码。
- 分析动态规划算法的正确性，并证明其最优性。
- 编写测试程序，验证动态规划算法的正确性。
三、实验结果与分析1. 排序算法实验结果：- 冒泡排序：时间复杂度O(n^2)，空间复杂度O(1)。
采用普里姆算法和克鲁斯卡尔算法,求最小生成树 -回复
采用普里姆算法和克鲁斯卡尔算法,求最小生成树-回复普里姆算法和克鲁斯卡尔算法是求解最小生成树问题的两种重要方法。
本文将详细介绍这两种算法的原理和步骤，并比较它们的优缺点和适用场景。
一、普里姆算法普里姆算法（Prim's Algorithm）是一种贪心算法，用于求解带权无向连通图的最小生成树。
它的基本思想是从一个起始顶点开始，逐步向最小代价的边添加顶点，直到生成一颗包含所有顶点的最小生成树。
下面是普里姆算法的具体步骤：1. 随机选择一个顶点作为起始顶点，并将其添加到最小生成树集合中。
2. 从最小生成树集合中已有的顶点出发，寻找与其相连的边中具有最小权值的顶点，将该顶点添加到最小生成树集合中。
3. 重复第二步，直到最小生成树集合包含所有顶点为止。
普里姆算法的时间复杂度为O(V^2)，其中V为顶点数。
它的优点是简单易懂、容易实现，并且适用于稠密图。
然而，普里姆算法对于稀疏图的效率较低，因为需要频繁地搜索和更新权值最小的边。
二、克鲁斯卡尔算法克鲁斯卡尔算法（Kruskal's Algorithm）是一种基于边的贪心算法，用于求解带权无向连通图的最小生成树。
它的基本思想是通过选择代价最小的边，并判断是否会形成环路，最终构建出一颗最小生成树。
下面是克鲁斯卡尔算法的具体步骤：1. 将图中的所有边按照权值从小到大进行排序。
2. 依次选择权值最小的边，判断如果添加该边会形成环路，则将其舍弃；否则将其添加到最小生成树的边集合中。
3. 重复第二步，直到最小生成树的边数等于顶点数减一为止。
克鲁斯卡尔算法的时间复杂度为O(ElogE)，其中E为边数。
相比普里姆算法，克鲁斯卡尔算法适用于稀疏图，并且对于大规模图的求解效率更高。
然而，克鲁斯卡尔算法的缺点是在构建最小生成树时需要尝试的边较多，因此在边数较多的情况下，算法的效率可能不高。
三、比较与总结普里姆算法和克鲁斯卡尔算法都是求解最小生成树问题的经典算法，它们各自具有不同的优点和适用场景。
克鲁斯卡尔算法求最小生成树完整代码
克鲁斯卡尔算法是一种用来求解最小生成树（Minimum Spanning Tree）的经典算法，它采用了贪心策略，能够高效地找到图中的最小生成树。
下面将为大家介绍克鲁斯卡尔算法的完整代码，希望对大家有所帮助。
1. 算法思路克鲁斯卡尔算法的基本思路是：首先将图中的所有边按照权值进行排序，然后从小到大依次考虑每条边，如果加入该边不会构成环，则将其加入最小生成树中。
在算法执行过程中，我们需要使用并查集来判断是否会构成环。
2. 代码实现接下来，我们将给出克鲁斯卡尔算法的完整代码，代码使用C++语言编写，具体如下：```cpp#include <iostream>#include <vector>#include <algorithm>using namespace std;// 定义图的边struct Edge {int u, v, weight;Edge(int u, int v, int weight) : u(u), v(v), weight(weight) {} };// 定义并查集class UnionFind {private:vector<int> parent;public:UnionFind(int n) {parent.resize(n);for (int i = 0; i < n; i++) {parent[i] = i;}}int find(int x) {if (parent[x] != x) {parent[x] = find(parent[x]);}return parent[x];}void Union(int x, int y) {int root_x = find(x);int root_y = find(y);if (root_x != root_y) {parent[root_x] = root_y;}}};// 定义比较函数用于排序bool cmp(const Edge a, const Edge b) {return a.weight < b.weight;}// 克鲁斯卡尔算法vector<Edge> kruskal(vector<Edge> edges, int n) { // 先对边进行排序sort(edges.begin(), edges.end(), cmp);// 初始化最小生成树的边集vector<Edge> res;UnionFind uf(n);for (int i = 0; i < edges.size(); i++) {int u = edges[i].u, v = edges[i].v, weight = edges[i].weight; // 判断是否构成环if (uf.find(u) != uf.find(v)) {uf.Union(u, v);res.push_back(edges[i]);}}return res;}// 测试函数int m本人n() {vector<Edge> edges;edges.push_back(Edge(0, 1, 4));edges.push_back(Edge(0, 7, 8));edges.push_back(Edge(1, 2, 8));edges.push_back(Edge(1, 7, 11));edges.push_back(Edge(2, 3, 7));edges.push_back(Edge(2, 5, 4));edges.push_back(Edge(2, 8, 2));edges.push_back(Edge(3, 4, 9));edges.push_back(Edge(3, 5, 14));edges.push_back(Edge(4, 5, 10));edges.push_back(Edge(5, 6, 2));edges.push_back(Edge(6, 7, 1));edges.push_back(Edge(6, 8, 6));edges.push_back(Edge(7, 8, 7));vector<Edge> res = kruskal(edges, 9);for (int i = 0; i < res.size(); i++) {cout << res[i].u << " " << res[i].v << " " << res[i].weight << endl;}return 0;}```3. 算法实例上述代码实现了克鲁斯卡尔算法，并对给定的图进行了最小生成树的求解。
算法实验报告贪心
一、实验背景贪心算法是一种在每一步选择中都采取当前状态下最好或最优的选择，从而希望导致结果是全局最好或最优的算法策略。
贪心算法并不保证能获得最优解，但往往能获得较好的近似解。
在许多实际应用中，贪心算法因其简单、高效的特点而被广泛应用。
本实验旨在通过编写贪心算法程序，解决经典的最小生成树问题，并分析贪心算法的优缺点。
二、实验目的1. 理解贪心算法的基本原理和应用场景；2. 掌握贪心算法的编程实现方法；3. 分析贪心算法的优缺点，并尝试改进；4. 比较贪心算法与其他算法在解决最小生成树问题上的性能。
三、实验内容1. 最小生成树问题最小生成树问题是指：给定一个加权无向图，找到一棵树，使得这棵树包含所有顶点，且树的总权值最小。
2. 贪心算法求解最小生成树贪心算法求解最小生成树的方法是：从任意一个顶点开始，每次选择与当前已选顶点距离最近的顶点，将其加入生成树中，直到所有顶点都被包含在生成树中。
3. 算法实现（1）数据结构- 图的表示：邻接矩阵- 顶点集合：V- 边集合：E- 已选顶点集合：selected- 最小生成树集合：mst（2）贪心算法实现```def greedy_mst(graph):V = set(graph.keys()) # 顶点集合selected = set() # 已选顶点集合mst = set() # 最小生成树集合for i in V:selected.add(i)mst.add((i, graph[i]))while len(selected) < len(V):min_edge = Nonefor edge in mst:u, v = edgeif v not in selected and (min_edge is None or graph[u][v] < graph[min_edge[0]][min_edge[1]]):min_edge = edgeselected.add(min_edge[1])mst.add(min_edge)return mst```4. 性能分析为了比较贪心算法与其他算法在解决最小生成树问题上的性能，我们可以采用以下两种算法：（1）Prim算法：从任意一个顶点开始，逐步添加边，直到所有顶点都被包含在生成树中。
离散数学大作业——编程实现最小生成树
离散数学大作业——编程实现最小生成树学院：电子工程学院班级：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。
克里斯卡尔算法最小生成树
克里斯卡尔算法最小生成树什么是克里斯卡尔算法？克里斯卡尔算法是一种求解最小生成树(Minimum Spanning Tree, MST)的算法，它采用贪心算法的思想，在给定一个连通图的情况下，通过逐步选择边来生成树，最终得到权值和最小的生成树。
为了更好地理解克里斯卡尔算法，我们首先要明确最小生成树的概念。
在一个连通图中，最小生成树是指连接图中所有顶点的树，并且树上所有边的权值之和最小。
生成树是一个无环的连通图，具有n个顶点的连通图的生成树必然含有n-1条边。
克里斯卡尔算法的步骤如下：1. 初始化：将图中的每个顶点看作是一个单独的树，每个树只包含一个节点。
同时，创建一个空的边集合用于存储最小生成树的边。
2. 对所有边按照权值进行升序排列。
3. 依次选择权值最小的边，并判断该边连接的两个节点是否属于不同的树（不属于同一个连通分量）。
4. 如果两个节点不属于同一个树，则将这条边添加到边集合中，并将两个节点合并为同一个连通分量。
5. 重复步骤3和步骤4，直到最小生成树的边数达到n-1条为止。
6. 返回边集合，即为最小生成树。
通过这个步骤的执行，克里斯卡尔算法能够保证运行过程中生成的树权值和是最小的。
这是因为在选择边时，我们总是选择权值最小且不会形成环路的边，这样生成的树就不会包含多余的边。
需要注意的是，克里斯卡尔算法适用于带权无向连通图，如果是带权有向图，需要先进行转化为无向图的操作。
另外，克里斯卡尔算法在实际应用中有着广泛的应用，比如网络设计、电路设计以及地图路线规划等领域。
总结一下，克里斯卡尔算法是一种通过贪心思想解决最小生成树问题的算法。
它通过逐步选择权值最小的边，并将不同的树合并为一个连通分量的方式，生成一个权值和最小的生成树。
在实际应用中，克里斯卡尔算法具有重要的意义，能够为我们提供高效、经济的解决方案。
通过了解和学习克里斯卡尔算法，我们能够更好地理解图论中的最小生成树问题，并运用其解决实际问题。
贪心算法设计实验报告
A
B
C
D
E
F
G
0
0
0
0
1
0
0
0
对表进行维护（维护后仍同上表，因为还没有两个集合合并）
0
A
B
C
D
E
F
G
0
0
0
0
1
0
0
0
C，选择第二条边 C----E （修改上表）
0
A
B
C
D
E
F
G
0
0
0
0
1
3
0
0
对上表进行维护（任同上表，因为还没有两个集合合并）
0
A
B
C
D
E
F
G
0
0
0
0
1
3
0
0
D，选择第三条边（ D-----F ） (根据条件 DF 两点不再同一集合，改边可选 ) 然后就合并 DF 两点所在的集合 D 的前去是 1，即 A 标记为 0， E 的标记也为 0，合并因为 6>1 所以表修改如下
Edge* selectionsort(Edge *array,int n)// 选择排序（对边按权重由高到低排序） {
int i,j,min,temp; for(i=0;i<n;i++) {
min=i; for(j=i+1;j<n;j++)
if(array[min].weight>array[j].weight) min=j;
在同一棵树上，则不可取，而应该取下一条权值最小的边再试之。依次类推，直至森林中
只有一棵树，也即子图中含有
贪心算法的应用案例
贪心算法的应用案例贪心算法是一种简单直观的算法策略，用于解决一些优化问题。
它的基本思想是在每一步选择中都选择当前状态下的最优解，以期望最终达到全局最优解。
本文将通过几个具体的应用案例来展示贪心算法的实际应用。
1. 最小生成树问题最小生成树问题是图论中经典的问题之一，主要涉及到如何在一个连通加权无向图中找到一个包含所有顶点且权重最小的树。
其中，贪心算法的应用使得问题的解决更加高效。
例如，我们有一个城市网络，城市之间的距离用边的权重表示，我们希望在城市之间建立最小的铁路网络以确保每个城市都能够连通。
这可以转化为一个最小生成树问题，其中贪心算法通过选择权重最小的边，快速找到最优解。
2. 零钱兑换问题零钱兑换问题是一个经典的动态规划问题，但同样可以使用贪心算法来解决。
给定一定面值的硬币，我们需要找零某个金额的钱，求出所需硬币的最少数量。
贪心算法解决这个问题的思路是，每次选择价值最大的硬币，直到凑够所需的金额。
这样可以保证得到的结果是最优解。
例如，假设我们有面值为[1, 5, 10, 25]的硬币，需要凑够30美分，贪心算法会优先选择25美分硬币，然后再选择5美分硬币，最后选择1美分硬币，总共需要三枚硬币。
贪心算法快速获得了最优解。
3. 区间调度问题区间调度问题是一类经典的贪心算法问题，主要涉及到如何在一组任务中选择最大数量的相容任务。
每个任务都有一个开始时间和结束时间，任务之间不能同时进行，我们需要找到最大数量的任务能够不发生冲突地进行。
贪心算法解决这个问题的思路是，每次选择结束时间最早的任务，然后排除与其冲突的任务，直到没有任务可选为止。
这样就能够保证选择的任务最多且不发生冲突。
例如，假设我们有以下任务与其对应的开始时间和结束时间：A(1, 4)，B(3, 6)，C(5, 7)。
贪心算法会先选择A(1, 4)，然后排除与其冲突的任务B(3, 6)，最后剩下任务C(5, 7)。
贪心算法得到了最大数量的相容任务。
Kruskal算法实现步骤
Kruskal算法实现步骤Kruskal算法是一种用于解决最小生成树问题的贪心算法。
它的基本思想是通过不断选取权值最小的边来构建最小生成树。
下面将详细介绍Kruskal算法的实现步骤。
步骤一：初始化首先，我们需要将所有的边按照权值从小到大进行排序。
这可以使用快速排序等常用的排序算法来实现。
同时，我们也需要一个数组来记录每个顶点所在的连通分量。
步骤二：选择最小边从排序后的边中选择权值最小的一条边，并判断这条边所连接的两个顶点是否在不同的连通分量中。
如果是的话，则选择这条边加入最小生成树中；如果不是，则舍弃这条边继续选择下一条权值最小的边。
步骤三：更新连通分量将所选取的边连接的两个顶点加入同一个连通分量中。
这可以通过更新数组来实现，将其中一个顶点的连通分量值赋为另一个顶点的连通分量值。
步骤四：重复步骤二和步骤三依次选择下一条权值最小的边，并重复进行步骤二和步骤三，直到最小生成树的边数达到顶点数减一，或者遍历完所有的边。
步骤五：输出最小生成树最后，将构建好的最小生成树输出，即得到了问题的解。
通过上述的五个步骤，我们可以使用Kruskal算法来求解最小生成树问题。
该算法的时间复杂度主要取决于对边的排序操作，一般为O(ElogE)，其中E为边的数量。
总结Kruskal算法是一种简单而有效的贪心算法，用于解决最小生成树问题。
它通过选择权值最小的边，并更新连通分量来逐步构建最小生成树。
该算法的核心是边的排序和判断两个顶点是否在同一连通分量中。
通过合理地使用该算法，我们可以在图论等领域中快速求解最小生成树的问题。
注意：本文仅为描述Kruskal算法实现步骤，未提供具体的代码实现。
如果您需要具体的代码，请参考相关的教材、论文或互联网资源。
普里姆实验报告
一、实验目的1. 理解普里姆算法的基本原理和步骤。
2. 掌握使用C语言实现普里姆算法的方法。
3. 熟悉最小生成树的概念及其在实际应用中的重要性。
4. 通过实验验证普里姆算法的正确性和效率。
二、实验环境1. 操作系统：Windows 102. 编程语言：C语言3. 开发环境：Visual Studio三、实验原理普里姆算法是一种贪心算法，用于在加权无向图中寻找最小生成树。
最小生成树是指一个无向图的所有顶点构成的树，其边权值之和最小。
普里姆算法的基本思想是从某个顶点开始，逐步增加边，直到包含所有顶点为止。
四、实验步骤1. 定义邻接矩阵：首先定义一个二维数组表示图的邻接矩阵，其中元素表示两个顶点之间的边权值。
2. 初始化数据结构：定义一个结构体表示顶点，包含顶点的编号和距离。
初始化一个数组存储所有顶点的结构体。
3. 选择起始顶点：选择一个顶点作为起始顶点，将其距离设置为0，其余顶点的距离设置为无穷大。
4. 遍历邻接矩阵：对于每个顶点，遍历其邻接矩阵，找到距离最小的边，将其加入最小生成树中，并更新相邻顶点的距离。
5. 重复步骤4：重复步骤4，直到所有顶点都被加入最小生成树中。
6. 输出结果：输出最小生成树的边和权值。
五、实验代码```c#include <stdio.h>#include <stdlib.h>#define MAXVEX 6#define INF 10000typedef struct {int adjvex; // 邻接顶点的位置int lowcost; // 与adjvex顶点相连的边的权值} MinNode;typedef struct {char vexs[MAXVEX]; // 顶点表MinNode adjmatrix[MAXVEX][MAXVEX]; // 邻接矩阵int numVertexes, numEdges; // 图中当前顶点的数量和边的数量} MGraph;void CreateMGraph(MGraph G) {int i, j, k, w;printf("请输入顶点数量和边数量：\n");scanf("%d %d", &G->numVertexes, &G->numEdges);printf("请输入顶点信息：\n");for (i = 0; i < G->numVertexes; i++) {scanf("%s", G->vexs[i]);}for (i = 0; i < G->numVertexes; i++) {G->adjmatrix[i][j].adjvex = 0;G->adjmatrix[i][j].lowcost = INF;}}for (k = 0; k < G->numEdges; k++) {printf("请输入边(%d)的两个顶点和权值：\n", k + 1); scanf("%d %d %d", &i, &j, &w);G->adjmatrix[i][j].adjvex = j;G->adjmatrix[i][j].lowcost = w;G->adjmatrix[j][i].adjvex = i;G->adjmatrix[j][i].lowcost = w;}}void Prim(MGraph G, int u) {int min, i, j, k;MinNode adjvex;int visited[MAXVEX] = {0}; // 标记顶点是否被访问过visited[u] = 1;printf("%c ", G.vexs[u]); // 输出起始顶点for (i = 1; i < G.numVertexes; i++) {min = INF;k = u;if (visited[j] == 0 && G.adjmatrix[k][j].lowcost < min) { min = G.adjmatrix[k][j].lowcost;adjvex = G.adjmatrix[k][j];k = j;}}printf("%c ", G.vexs[k]); // 输出当前顶点visited[k] = 1;G.adjmatrix[u][k].lowcost = INF;G.adjmatrix[k][u].lowcost = INF;}}int main() {MGraph G;int u;printf("请输入起始顶点编号：\n");scanf("%d", &u);CreateMGraph(&G);Prim(G, u);return 0;}```六、实验结果1. 输入顶点数量和边数量：6 82. 输入顶点信息：A B C D E F3. 输入边(1)的两个顶点和权值：0 1 14. 输入边(2)的两个顶点和权值：0 2 25. 输入边(3)的两个顶点和权值：1 2 36. 输入边(4)的两个顶点和权值：1 3 67. 输入边(5)的两个顶点和权值：2 3 48. 输入边(6)的两个顶点和权值：2 4 59. 输入边(7)的两个顶点和权值：3 4 710. 输入边(8)的两个顶点和权值：4 5 811. 输入起始顶点编号：0实验结果：A B C D E F七、实验总结通过本次实验，我们成功实现了普里姆算法，并验证了其在实际应用中的有效性。
生成树实验报告
一、实验目的1. 理解生成树的概念和作用；2. 掌握Prim算法和Kruskal算法实现生成树的方法；3. 分析算法的时间复杂度和空间复杂度；4. 提高算法设计与分析能力。
二、实验原理生成树（Spanning Tree）是一个无向图的所有顶点构成的一棵树，且该树包含了原图的所有顶点。
生成树在计算机网络、电路设计等领域具有广泛的应用。
在无向图中，如果任意两个顶点之间都存在路径，则称该图是连通的。
对于连通图，一定存在一棵生成树。
Prim算法和Kruskal算法是两种常见的生成树算法，它们分别采用贪心策略和最小生成树算法实现。
三、实验内容1. Prim算法实现生成树（1）初始化：设置一个数组来记录每个顶点与当前生成树的连接情况，以及一个数组来记录每个顶点到生成树的距离。
（2）选择一个顶点作为起始顶点，将其距离设置为0，其他顶点距离设置为无穷大。
（3）在当前生成树上选择距离最小的顶点，将其加入生成树，并将该顶点与其他顶点的距离更新。
（4）重复步骤（3），直到所有顶点都被加入生成树。
2. Kruskal算法实现生成树（1）将所有边按照权值从小到大排序。
（2）创建一个并查集，用于判断两个顶点是否属于同一个集合。
（3）遍历排序后的边，对于每条边，判断其两个顶点是否属于同一个集合：（a）如果属于同一个集合，则跳过该边；（b）如果不属于同一个集合，则将这条边加入生成树，并将两个顶点所属的集合合并。
（4）重复步骤（3），直到生成树包含所有顶点。
四、实验步骤1. 创建一个无向图，包含若干顶点和边。
2. 使用Prim算法实现生成树，记录算法运行时间。
3. 使用Kruskal算法实现生成树，记录算法运行时间。
4. 分析两种算法的时间复杂度和空间复杂度。
五、实验结果与分析1. Prim算法实现生成树（1）顶点集合：V = {A, B, C, D, E, F}（2）边集合：E = {(A, B, 1), (A, C, 3), (A, D, 2), (B, C, 2), (B, D, 2), (C, D, 1), (C, E, 4), (D, E, 3), (D, F, 2), (E, F, 1)}（3）Prim算法运行时间：0.001秒2. Kruskal算法实现生成树（1）顶点集合：V = {A, B, C, D, E, F}（2）边集合：E = {(A, B, 1), (A, C, 3), (A, D, 2), (B, C, 2), (B, D, 2), (C, D, 1), (C, E, 4), (D, E, 3), (D, F, 2), (E, F, 1)}（3）Kruskal算法运行时间：0.001秒通过实验，我们可以得出以下结论：1. Prim算法和Kruskal算法均可以有效地实现生成树，且在时间复杂度和空间复杂度上表现良好。
实现最小生成树算法(Python)
实现最小生成树算法（Python）最小生成树（MST）是图论中的一个重要问题，它的应用非常广泛。
在计算机科学中，最小生成树问题被广泛应用在网络设计、电路布线、系统优化等领域。
在本文中，我们将介绍最小生成树算法的基本概念、常见的算法实现以及应用场景。
1.最小生成树的定义首先，让我们来了解一下最小生成树的定义。
最小生成树是指一个无向图的生成树，它的所有边的权值之和最小。
换句话说，最小生成树是一个连通图的生成树，它包含图中的所有顶点，但是边的权值之和最小。
在一个无向图G=(V,E)中，V表示顶点集合，E表示边集合。
每条边e∈E都有一个权值w(e)。
一个最小生成树T是一个包含了图中所有顶点的生成树，并且它的边的权值之和最小。
换句话说，如果T'是G的另一个生成树，那么T的权值小于等于T'的权值。
最小生成树问题是一个经典的优化问题，在实际应用中有着广泛的应用。
接下来，我们将介绍常见的最小生成树算法实现，包括Prim算法和Kruskal算法。
2. Prim算法Prim算法是一种常见的贪心算法，它可以求解最小生成树问题。
Prim算法的基本思想是从一个初始顶点开始，逐步加入未访问的顶点，并选择与当前生成树相连的权值最小的边。
该算法的具体步骤如下：步骤1：初始化一个空的生成树T，选择一个初始顶点作为起始点。
步骤2：将起始点加入T，并将其标记为已访问。
步骤3：重复以下步骤，直到T包含所有顶点为止。
步骤4：从T中找到与未访问顶点相连的权值最小的边e，并将其加入T。
步骤5：将边e相连的顶点标记为已访问。
步骤6：重复步骤4和步骤5，直到T包含所有顶点。
通过上述步骤，Prim算法可以得到一个最小生成树。
该算法的时间复杂度为O(V^2)，其中V表示图中的顶点数。
在实际应用中，Prim算法通常通过优先队列来实现，以降低时间复杂度。
3. Kruskal算法Kruskal算法是另一种常见的最小生成树算法，它基于图的边来构造最小生成树。
贪心算法实验报告(C语言)
实验2、《贪心算法实验》一、实验目的1. 了解贪心算法思想2. 掌握贪心法典型问题，如背包问题、作业调度问题等。
二、实验内容1. 编写一个简单的程序，实现单源最短路径问题。
2. 编写一段程序，实现找零。
【问题描述】当前有面值分别为2角5分，1角，5分，1分的硬币，请给出找n分钱的最佳方案（要求找出的硬币数目最少）。
3. 编写程序实现多机调度问题【问题描述】要求给出一种作业调度方案，使所给的n个作业在尽可能短的时间内由m 台机器加工处理完成。
约定，每个作业均可在任何一台机器上加工处理，但未完工前不允许中断处理。
作业不能拆分成更小的子作业。
三、算法思想分析1.初始化将源点设计为红点集，其余点设计为蓝点，重复选择蓝点集中与源点路径最短的点加入红点集，更新剩余的蓝点集路径，直至蓝点集为空或者只剩下没有连通的点，那么源点到其余所有点的最短路径就出来了。
2.找零问题是典型的贪心问题，但是并不代表所有的找零都能用贪心算法找到最优解。
只有满足贪心选择性质的找零才能找到最优解，本题满足贪心选择性质，直接先一直选面值最大的硬币，再一次减小即可。
3.先对作业按时长进行重排序，再依次找目前用时最短的机器安排工作并加上对应时长，最后总时长为机器中用时最长的那个时长。
四、实验过程分析1.单源最短路径的算法思想并不难，但是在实际编码过程中还是有很多小问题需要注意，首先，一定要新建数组存储路径变化，因为后面计算路径时会用到原数组，如果直接在原数组上更改后面就找不到原数据了，那么就会出现偏差。
其次就是建议先写个伪代码，判断的if-else语句比较多，容易搞混，在代码中一定要及时备注，某些代码的功能是什么，不然再次看代码时需要思考很久甚至忘记。
2.找零问题直接用while循环或者不断取余取模即可解决。
3.作业调度问题大致分为三步，一是排序，二是不断找最短时长的机器安排作业，三是找最长时间为作业完成时间。
五、算法源代码及用户屏幕1.（1）算法源码/**********************单源最短路径问题。
最小生成树(prim算法)贪心算法
最小生成树算法Prim算法设G=(V,E)是连通带权图，V={1,2,…,n}。
构造G的最小生成树的Prim算法的基本思想是：(1)置S={1}(2)只要S是V的真子集，就作如下的贪心选择选取满足条件i ∈ S，j ∈ V-S，且c[i][j]最小的边，将顶点j添加到S中。
一直到S=V时为止。
(2)选取到的所有边恰好构成G的一棵最小生成树。
源代码：//科目：算法实验4//题目：设G=(V,E)是连通带权图，V={1,2,…,n}。
构造G的最小生成树的Prim算法//作者：武叶//语言：C语言//创作时间：2012年4月14日#include"stdio.h"int point[100],key_point[100],tree[100][100]; //定义三个数组用于存放关键点和最小生成树int INT_MAX=0x7fff;void prim(int end,int V); //prim算法函数int main(){int V,E; //定义顶点数V和边数Eint i,j;int start,end,distance; //定义开始顶点start和结束顶点end，以及他们的权值distanceprintf("请输入连通带权图的边数和顶点数：");while(scanf("%d%d",&V,&E)) //开始输入你要求最小生成树的顶点数和边数{printf("\n------------------------------------");for(i=1;i<=V;i++){for(j=1;j<=V;j++)tree[i][j]=INT_MAX;}printf("\n请输入%d条边的起点和终点，以及权值。
\n",E);printf("\n----------------------------------------\n");int x=1; //用x记录输入的边数while(E--){printf("第%d条边的起点：终点：权值：",x);scanf("%d%d%d",&start,&end,&distance); //记录输入的起点、终点、权值tree[start][end]=tree[end][start]=distance;x=x+1;}prim(1,V); //调用prim计算最小生成树printf("\n");}return 0;}void prim(int end,int V){int min; //定义权值最小值minfor(int i=1;i<=V;i++){point[i]=end;key_point[i]=tree[end][i];}key_point[end]=0;for(i=2;i<=V;i++){min= INT_MAX;for(int j=1;j<=V;j++)if(key_point[j]>0 && key_point[j]<min){end=j;min=key_point[j];}printf("起点%d-->终点%d连通\n",point[end],end); //输出最小生成树的连通边key_point[end]=0;for(j=1;j<=V;j++) //继续判断条件if(tree[end][j]<key_point[j])point[j]=end,key_point[j]=tree[end][j];}}运行结果截图：答销网真情提供：：文章出处：：：：/forum.php?mod=viewthread&tid=1533&extra=page%3D1%26filter%3Dtypeid%26typeid%3D3%26typeid%3D3。
最小生成树实验报告
最小生成树实验报告1.引言最小生成树（Minimum Spanning Tree，简称MST）是图论中的重要概念，在各个领域都有广泛的应用。
最小生成树是指在给定的加权连通图中，选择一个子集，使得该子集包含了所有的顶点，并且所有边的权值之和最小。
本实验主要目的是探讨最小生成树的算法并比较它们的效率和准确性。
2.实验方法本次实验使用Python编程语言实现了两种著名的最小生成树算法：Prim算法和Kruskal算法。
Prim算法是一种贪心算法，从一个顶点开始不断扩张集合，直到包含所有顶点，生成最小生成树。
Kruskal算法则是基于并查集的算法，将边按照权值排序后逐一加入生成树，同时要保证加入的边不会产生环路。
3.实验过程首先，我们从文件中读取了一张加权无向图的数据。
图的表示采用邻接矩阵的方式，即用一个二维数组来存储顶点之间的连接关系和权值。
读取完图的数据后，我们分别使用Prim算法和Kruskal算法求解最小生成树。
在Prim算法中，我们使用一个辅助数组来记录顶点是否已被访问过，然后从任意一个顶点开始，依次将与当前集合相邻的顶点加入，并选择权值最小的边。
直到所有顶点都被访问过，并形成了一个最小生成树。
在Kruskal算法中，我们首先将所有边按照权值从小到大进行排序。
然后，从权值最小的边开始，逐一将边加入生成树。
加入时，需要判断两个顶点是否在同一个连通分量中，以避免产生环路。
实验中，我们使用了Python中的heapq库来实现了堆排序，以加快Prim算法的运行速度。
4.实验结果经过实验，我们得到了图的最小生成树以及对应的权值。
实验数据显示，当图中顶点较少时，Prim算法和Kruskal算法几乎没有明显的差别。
但当图的规模增大时，Prim算法明显比Kruskal算法更快。
5.实验分析从实验结果可以看出，Prim算法和Kruskal算法都可以求解最小生成树，但在不同情况下它们的性能表现并不相同。
Prim算法适用于稠密图，因为它的时间复杂度与顶点的平方成正比；而Kruskal算法适用于稀疏图，因为它的时间复杂度与边的数量成正比。
最小生成树算法实验报告_2
作业1最小生成树的生成算法1.1算法应用背景在实际生活中, 图的最小花费生成树问题有着广泛的应用。
例如, 用图的顶点代表城市, 顶点与顶点之间的边代表城市之间的道路或通信线路, 用边的权代表道路的长度或通信线路的费用, 则最小花费生成树问题, 就表示为城市之间最短的道路或费用最小的通信线路问题。
其中普里姆算法是使用贪婪法策略设计的典型算法。
1.2算法原理在一给定的无向图G = (V, E) 中, (u, v) 代表连接顶点u 与顶点v 的边（即）, 而w(u, v) 代表此边的权重, 若存在T 为E 的子集（即）且为无循环图, 使得的w(T) 最小, 则此T 为G 的最小生成树。
许多应用问题都是一个求无向连通图的最小生成树问题。
例如：要在n个城市之间铺设光缆, 主要目标是要使这n 个城市的任意两个之间都可以通信, 但铺设光缆的费用很高, 且各个城市之间铺设光缆的费用不同；另一个目标是要使铺设光缆的总费用最低。
这就需要找到带权的最小生成树。
1.3算法描述1)最小生成树之普里姆算法描述:令G=(V,E,W), 为简单期间, 令顶点集为V={0,1,2…, n-1}。
假定与顶点i, j相关联的边为ei, j, ei, j的权用c[i][j]表示, T是最小花费生成树的边集。
这个算法维护两个顶点集合S 和N, 开始时: 令T=Ф,S={0},N=V-S。
然后, 进行贪婪选择, 选取i∈S, j∈N, 并且c[i][j]最小的i和j；并使S=S∪S{j},N=N-{j},T=T∪{ei, j}.重复上述步骤, 直到N为空, 或找到n-1条边为止。
此时, T中的边集, 就是所要求取的G中的最小花费生成树。
由此, 可描述普里姆算法的步骤如下:（1）T=Ф, S={0},N=V-S。
（2）如果N为空, 算法结束；否则, 转步骤（3）。
（3）寻找使i∈S, j∈N, 并且c[i][j]最小的i和j。
（4）S=S∪S{j},N=N-{j},T=T∪{ei, j}；转步骤（2）。
最小生成树例题贪心算法c语言算法与设计
最小生成树例题贪心算法c语言算法与设计题目：最小生成树例题——贪心算法在C语言算法与设计中的应用引言:在算法和数据结构的学习过程中，贪心算法是一种常见且重要的思想。
它通过每一步局部最优的选择来构建整体最优解。
最小生成树问题是贪心算法的经典例题之一，而在C语言算法与设计中，理解并应用贪心算法是非常必要的。
本文将围绕最小生成树例题展开，探讨贪心算法在C语言算法与设计中的应用。
一、最小生成树（Minimum Spanning Tree）的定义与理解1.1 概念解析最小生成树是图论中的一个概念，它指的是在连通图中找到一棵树，使得这棵树的所有边的权值之和最小。
最小生成树常应用于优化问题，如电缆布线以及城市间道路建设等。
1.2 算法应用最小生成树常用于解决具有边权的连通图问题。
在实际应用中，我们通常使用Kruskal算法或Prim算法来求解最小生成树。
二、Kruskal算法详解2.1 思想描述Kruskal算法是一种基于贪心思想的算法，其主要思路是依次选择边权最小且不形成回路的边，直到生成最小生成树。
2.2 具体步骤（1）将图中的所有边按照权值从小到大进行排序；（2）从权值最小的边开始，如果该边的两个端点不在同一个连通分量中，则将其加入最小生成树，并合并两个连通分量；（3）重复步骤（2），直到最小生成树包含图中的所有节点。
2.3 例子分析以以下图为例说明Kruskal算法的应用过程：```（图1）```（1）将图中的边按照权值从小到大排序得到如下顺序：```A-B: 1E-F: 1B-C: 2E-G: 2C-D: 3D-F: 3F-G: 4```（2）选取权值最小的边A-B，并将A和B加入最小生成树。
此时连通分量为{A}和{B}。
```（图2）```（3）选取权值次小的边E-F，可以将其加入最小生成树，同时连通分量中加入F。
此时连通分量为{A}，{B}和{F}。
```（图3）```（4）依次选择权值较小的边，直到最小生成树中包含图中的所有节点。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
实验一用贪心算法实现最小生成树问题
一．实验目的
1.熟悉贪心算法的基本原理和使用范围。
二．实验内容及要求
内容：任选一种贪心算法（prim或Kruskal），求解最小生成树。
对算法进行编程。
要求：使用贪心算法编程，求解最小生成树问题
三．程序列表
（1）prim算法
#include<stdio.h>
#define INF 32766
#define max 40
void prim(int g[][max],int n)
{
int lowcost[max],closest[max];
int i,j,k,min;
for(i=2;i<=n;i++)
{
lowcost[i]=g[1][i];
closest[i]=1;
}
lowcost[1]=0;
for(i=2;i<=n;i++)
{
min=INF;
k=0;
for(j=2;j<=n;j++)
{
if((lowcost[j]<min)&&(lowcost[j]!=0))
{
min=lowcost[j];
k=j;
}
}
printf("(%d,%d)%d\t",closest[k],k,min);
lowcost[k]=0;
for(j=2;j<=n;j++)
{
if(g[k][j]<lowcost[j])
{
lowcost[j]=g[k][j];
closest[j]=k;
}
}
printf("\n");
}
}
int adj(int g[][max])
{
int n,i,j,v1,v2,weight,m;
printf("输入顶点数 n=:");
scanf("%d",&n);
for(i=1;i<=n;i++)
for(j=1;j<=n;j++)
g[i][j]=INF;
while(v1!=0&&v2!=0&&weight!=0)//只要输入0 0 0就结束{
printf("v1,v2,weight=");
scanf("%d %d %d",&v1,&v2,&weight);
g[v1][v2]=weight;
g[v2][v1]=weight;
}
return(n);
}
void prg(int g[][max],int n)
{
int i,j;
for(i=0;i<=n;i++)
printf("%d\t",i);
for(i=1;i<=n;i++)
{
printf("\n%d\t",i);
for(j=1;j<=n;j++)
printf((g[i][j]==INF)?"\t":"%d\t",g[i][j]);
}
printf("\n");
}
void main()
{
int g[max][max],n,i;
n=adj(g);
printf("输出无向图的邻接矩阵:\n");
prg(g,n);
printf("输出最小生成树:\n");
prim(g,n);
}
四．实验结果。