一个不知名大学生，江湖人称菜狗
original author: jacky Li
Email : 3435673055@qq.com

Time of completion：2022.12.10
Last edited: 2022.12.11

算法6.7BFS

第1关：算法6.7 BFS

任务描述

相关知识

编程要求

输入输出说明

测试说明

代码参考

第2关：算法6.7改进邻接表BFS

任务描述

相关知识

编程要求

输入输出说明

测试说明

参考代码

第3关：算法6.7非连通图邻接表BFS

任务描述

相关知识

编程要求

输入输出说明

测试说明

参考代码

算法6.8-6.9最小生成树

第1关：算法6.8 prim算法

任务描述

相关知识

编程要求

输入输出说明

测试说明

参考代码

第2关：算法6.9 kruskal算法

任务描述

相关知识

编程要求

输入输出说明

测试说明

参考代码

作者有言

算法6.7BFS

第1关：算法6.7 BFS

任务描述

本关任务：编写一个采用邻接矩阵表示图的广搜程序。

编程要求

根据提示，在右侧编辑器补充代码，输出由一个顶点出发的广搜路径。

输入输出说明

输入说明：第一行为顶点数n和边数e 第二行为n个顶点符号接下来e行为e条边，每行两个字符代表无向图的一条边最后一行仅包含一个字符，代表广搜开始顶点输出说明：一条路径，顶点之间用空格分隔

测试说明

平台会对你编写的代码进行测试：

测试输入：

4 4

a b c d

a b

a c

b d

c d

b

测试输出：

b a d c

代码参考

//算法6.7　广度优先搜索遍历连通图
#include <iostream>
#include <algorithm>
#include <map>
#include <cmath>
#include <cstring>#define IOS std::ios::sync_with_stdio(false)
//#define YES cout << "1"
//#define NO cout << "0"
#define MaxInt 0x3f
#define MAXQSIZE 100                        //最大队列长度
#define MVNum 100
#define OK 1
#define ERROR -1const int N = 1003;using namespace std;
typedef long long LL;typedef char VerTexType;                   //假设顶点的数据类型为字符型
typedef int ArcType;                        //假设边的权值类型为整型
bool visited[MVNum];                        //访问标志数组，其初值为"false" //-----图的邻接矩阵存储表示-----
typedef struct{ VerTexType vexs[MVNum];                 //顶点表ArcType arcs[MVNum][MVNum];            //邻接矩阵int vexnum,arcnum;                        //图的当前点数和边数
}Graph;//----队列的定义及操作--------
typedef struct{ArcType *base;                           //初始化的动态分配存储空间int front;                                //头指针，若队列不空，指向队头元素int rear;                               //尾指针，若队列不空，指向队尾元素的下一个位置
}sqQueue;void InitQueue(sqQueue &Q){//构造一个空队列QQ.base = new ArcType[MAXQSIZE];if(!Q.base)     exit(1);              //存储分配失败Q.front = Q.rear = 0;
}//InitQueuevoid EnQueue(sqQueue &Q, ArcType e){//插入元素e为Q的新的队尾元素if((Q.rear + 1) % MAXQSIZE == Q.front)return;Q.base[Q.rear] = e;Q.rear = (Q.rear + 1) % MAXQSIZE;
}//EnQueuebool QueueEmpty(sqQueue Q){//判断是否为空队if(Q.rear == Q.front)return true;return false;
}//QueueEmptyvoid DeQueue(sqQueue &Q, ArcType &u){//队头元素出队并置为u u = Q.base[Q.front];Q.front = (Q.front + 1) % MAXQSIZE;
}//DeQueue
//--------------------------------------------------int LocateVex(Graph G , VerTexType v){//确定点v在G中的位置for(int i = 0; i < G.vexnum; ++i)if(G.vexs[i] == v)return i;return -1;
}//LocateVexvoid CreateUDN(Graph &G)
{ //采用邻接矩阵表示法，创建无向网G int i , j , k;cin >> G.vexnum >> G.arcnum;                          //输入总顶点数，总边数for(i = 0; i < G.vexnum; ++i)   cin >> G.vexs[i];                                    //依次输入点的信息 for(i = 0; i < G.vexnum; ++i)                          //初始化邻接矩阵，边的权值均置为极大值MaxInt for(j = 0; j < G.vexnum; ++j)   G.arcs[i][j] = 0; for(k = 0; k < G.arcnum;++k){                          //构造邻接矩阵 VerTexType v1 , v2;cin >> v1 >> v2;                                    //输入一条边依附的顶点i = LocateVex(G, v1);  j = LocateVex(G, v2);      //确定v1和v2在G中的位置，即顶点数组的下标 G.arcs[i][j] = 1;                                  //边<v1, v2>的权值置为w G.arcs[j][i] = 1;                      //置<v1, v2>的对称边<v2, v1>的权值为w }//for
}//CreateUDNint FirstAdjVex(Graph G , int v){//返回v的第一个邻接点int i;for(i = 0 ; i < G.vexnum ; ++i){if(G.arcs[v][i] == 1 && visited[i] == false)return i;}return -1;
}//FirstAdjVexint NextAdjVex(Graph G , int u , int w){//返回v相对于w的下一个邻接点int i;for(i = w ; i < G.vexnum ; ++i){if(G.arcs[u][i] == 1 && visited[i] == false)return i;}return -1;
}//NextAdjVexvoid BFS (Graph G, int v){
/************************Begin********************/sqQueue Q;for(int i=0;i<G.vexnum;++i)visited[i] = false;InitQueue(Q);for(int i=0;i<G.vexnum;++i){if(!visited[i])cout<<G.vexs[v]<<" ";         //访问v顶点 visited[v] = 1;        //修改该顶点对应数组的值为true EnQueue(Q,v);            //入队 while(!QueueEmpty(Q)){     //不空还有未遍历到的节点 DeQueue(Q,v);     //出队v for(int w = FirstAdjVex(G,v);w>=0;w=NextAdjVex(G,v,w))      //找到所有符合条件的邻接节点 if(!visited[w]){        //w是否被访问 cout<<G.vexs[w]<<" ";            //访问 visited[w] = 1;   //修改该顶点对应数组的值为trueEnQueue(Q,w);     //入队 }}}
/************************End**********************/
}//BFS int main(){Graph G;CreateUDN(G);VerTexType c;cin >> c;int i;for(i = 0 ; i < G.vexnum ; ++i){if(c == G.vexs[i])break;}BFS(G , i);return 0;
}//main

第2关：算法6.7改进邻接表BFS

任务描述

本关任务：编写一个采用邻接表表示图的广搜程序。

编程要求

根据提示，在右侧编辑器补充代码，输出由一个顶点出发的广搜路径。

输入输出说明

测试说明

平台会对你编写的代码进行测试：

测试输入：

4 4

a b c d

a b

a c

b d

c d

b

测试输出：

b a d c

参考代码

//算法6.7　广度优先搜索遍历连通图
#include <iostream>
#include <algorithm>
#include <map>
#include <cmath>
#include <cstring>#define IOS std::ios::sync_with_stdio(false)
//#define YES cout << "1"
//#define NO cout << "0"
#define MaxInt 0x3f
#define MAXQSIZE 100                        //最大队列长度
#define MVNum 100
#define OK 1
#define ERROR -1const int N = 1003;using namespace std;
typedef long long LL;typedef char VerTexType;                   //假设顶点的数据类型为字符型
typedef int ArcType;                        //假设边的权值类型为整型
bool visited[MVNum];                        //访问标志数组，其初值为"false" typedef struct ArcNode{                       //边结点 int adjvex;                           //该边所指向的顶点的位置 struct ArcNode *nextarc;                  //指向下一条边的指针
}ArcNode; typedef struct VNode{ VerTexType data;                        //顶点信息ArcNode *firstarc;                        //指向第一条依附该顶点的边的指针
}VNode, AdjList[MVNum];                     //AdjList表示邻接表类型 typedef struct{AdjList vertices;                       //邻接表 int vexnum, arcnum;                   //图的当前顶点数和边数
}ALGraph;typedef struct{ArcType *base;                          //初始化的动态分配存储空间int front;                                //头指针，若队列不空，指向队头元素int rear;                               //尾指针，若队列不空，指向队尾元素的下一个位置
}sqQueue;void InitQueue(sqQueue &Q){//构造一个空队列QQ.base = new ArcType[MAXQSIZE];if(!Q.base)     exit(1);              //存储分配失败Q.front = Q.rear = 0;
}//InitQueuevoid EnQueue(sqQueue &Q, ArcType e){//插入元素e为Q的新的队尾元素if((Q.rear + 1) % MAXQSIZE == Q.front)return;Q.base[Q.rear] = e;Q.rear = (Q.rear + 1) % MAXQSIZE;
}//EnQueuebool QueueEmpty(sqQueue Q){//判断是否为空队if(Q.rear == Q.front)return true;return false;
}//QueueEmptyvoid DeQueue(sqQueue &Q, ArcType &u){//队头元素出队并置为u u = Q.base[Q.front];Q.front = (Q.front + 1) % MAXQSIZE;
}//DeQueue                                  int LocateVex(ALGraph G , VerTexType v){//确定点v在G中的位置for(int i = 0; i < G.vexnum; ++i)if(G.vertices[i].data == v)return i;return -1;
}//LocateVexvoid CreateUDG(ALGraph &G)
{ //采用邻接表表示法，创建无向图Gint i , k;cin >> G.vexnum >> G.arcnum;                //输入总顶点数，总边数 for(i = 0; i < G.vexnum; ++i){            //输入各点，构造表头结点表cin >> G.vertices[i].data;               //输入顶点值 G.vertices[i].firstarc=NULL;           //初始化表头结点的指针域为NULL }//forfor(k = 0; k < G.arcnum;++k){                //输入各边，构造邻接表VerTexType v1 , v2;int i , j;cin >> v1 >> v2;                        //输入一条边依附的两个顶点i = LocateVex(G, v1);  j = LocateVex(G, v2);//确定v1和v2在G中位置，即顶点在G.vertices中的序号 ArcNode *p1=new ArcNode;                  //生成一个新的边结点*p1 p1->adjvex=j;                        //邻接点序号为j p1->nextarc= G.vertices[i].firstarc;  G.vertices[i].firstarc=p1;  //将新结点*p1插入顶点vi的边表头部ArcNode *p2=new ArcNode;                //生成另一个对称的新的边结点*p2 p2->adjvex=i;                          //邻接点序号为i p2->nextarc= G.vertices[j].firstarc;  G.vertices[j].firstarc=p2;  //将新结点*p2插入顶点vj的边表头部 }//for
}//CreateUDGvoid BFS (ALGraph G, int v){ //按广度优先非递归遍历连通图G int u;ArcNode *p;sqQueue Q;cout<<G.vertices[v].data<<"    ";visited[v]=true;InitQueue(Q);EnQueue(Q,v);while(!QueueEmpty(Q)){DeQueue(Q,u);p=G.vertices[u].firstarc;while(p){if(!visited[p->adjvex]) {cout<<G.vertices[p->adjvex].data<<"    ";visited[p->adjvex]=true;EnQueue(Q,p->adjvex);}p=p->nextarc;}}
}//BFS int main(){ALGraph G;CreateUDG(G);VerTexType c;cin >> c;int i;for(i = 0 ; i < G.vexnum ; ++i){if(c == G.vertices[i].data)break;}BFS(G , i);return 0;
}//main

第3关：算法6.7非连通图邻接表BFS

任务描述

本关任务：编写一个采用邻接表表示图的广搜程序。

编程要求

根据提示，在右侧编辑器补充代码，输出由一个顶点出发的广搜路径。

输入输出说明

测试说明

平台会对你编写的代码进行测试：

测试输入：

8 8

a b c d e f g h

a b

a c

b d

c d

e f

e g

g h

f h

测试输出：

a c b d e g f h

参考代码

#include <iostream>
#include <algorithm>
#include <map>
#include <cmath>
#include <cstring>#define IOS std::ios::sync_with_stdio(false)
//#define YES cout << "1"
//#define NO cout << "0"
#define MaxInt 0x3f
#define MAXQSIZE 100                        //最大队列长度
#define MVNum 100
#define OK 1
#define ERROR -1const int N = 1003;using namespace std;
typedef long long LL;typedef char VerTexType;                   //假设顶点的数据类型为字符型
typedef int ArcType;                        //假设边的权值类型为整型
bool visited[MVNum];                        //访问标志数组，其初值为"false" //-------------图的邻接表---------------------
typedef struct ArcNode{                     //边结点 int adjvex;                           //该边所指向的顶点的位置 struct ArcNode *nextarc;                  //指向下一条边的指针
}ArcNode; typedef struct VNode{ VerTexType data;                        //顶点信息ArcNode *firstarc;                        //指向第一条依附该顶点的边的指针
}VNode, AdjList[MVNum];                     //AdjList表示邻接表类型 typedef struct{AdjList vertices;                       //邻接表 int vexnum, arcnum;                   //图的当前顶点数和边数
}ALGraph;typedef struct{ArcType *base;                          //初始化的动态分配存储空间int front;                                //头指针，若队列不空，指向队头元素int rear;                               //尾指针，若队列不空，指向队尾元素的下一个位置
}sqQueue;void InitQueue(sqQueue &Q){//构造一个空队列QQ.base = new ArcType[MAXQSIZE];if(!Q.base)     exit(1);              //存储分配失败Q.front = Q.rear = 0;
}//InitQueuevoid EnQueue(sqQueue &Q, ArcType e){//插入元素e为Q的新的队尾元素if((Q.rear + 1) % MAXQSIZE == Q.front)return;Q.base[Q.rear] = e;Q.rear = (Q.rear + 1) % MAXQSIZE;
}//EnQueuebool QueueEmpty(sqQueue Q){//判断是否为空队if(Q.rear == Q.front)return true;return false;
}//QueueEmptyvoid DeQueue(sqQueue &Q, ArcType &u){//队头元素出队并置为u u = Q.base[Q.front];Q.front = (Q.front + 1) % MAXQSIZE;
}//DeQueue                                  int LocateVex(ALGraph G , VerTexType v){//确定点v在G中的位置for(int i = 0; i < G.vexnum; ++i)if(G.vertices[i].data == v)return i;return -1;
}//LocateVexvoid CreateUDG(ALGraph &G){ //采用邻接表表示法，创建无向图Gint i , k;cin >> G.vexnum >> G.arcnum;              //输入总顶点数，总边数 for(i = 0; i < G.vexnum; ++i){            //输入各点，构造表头结点表cin >> G.vertices[i].data;               //输入顶点值 G.vertices[i].firstarc=NULL;           //初始化表头结点的指针域为NULL }//forfor(k = 0; k < G.arcnum;++k){                //输入各边，构造邻接表VerTexType v1 , v2;int i , j;cin >> v1 >> v2;                        //输入一条边依附的两个顶点i = LocateVex(G, v1);  j = LocateVex(G, v2);//确定v1和v2在G中位置，即顶点在G.vertices中的序号 ArcNode *p1=new ArcNode;                  //生成一个新的边结点*p1 p1->adjvex=j;                        //邻接点序号为j p1->nextarc= G.vertices[i].firstarc;  G.vertices[i].firstarc=p1;  //将新结点*p1插入顶点vi的边表头部ArcNode *p2=new ArcNode;                //生成另一个对称的新的边结点*p2 p2->adjvex=i;                          //邻接点序号为i p2->nextarc= G.vertices[j].firstarc;  G.vertices[j].firstarc=p2;  //将新结点*p2插入顶点vj的边表头部 }//for
}//CreateUDGvoid BFS (ALGraph G, int v){ //按广度优先非递归遍历连通图G int u;ArcNode *p;sqQueue Q;cout<<G.vertices[v].data<<"    ";visited[v]=true;InitQueue(Q);EnQueue(Q,v);while(!QueueEmpty(Q)){DeQueue(Q,u);p=G.vertices[u].firstarc;while(p){if(!visited[p->adjvex]) {cout<<G.vertices[p->adjvex].data<<"    ";visited[p->adjvex]=true;EnQueue(Q,p->adjvex);}p=p->nextarc;}}
}//BFS int main(){ALGraph G;CreateUDG(G);for(int v=0;v<G.vexnum;v++)  visited[v]=false;for(int v=0;v<G.vexnum;v++)if(!visited[v])  {cout<<endl;BFS(G,v); }return 0;
}//main

算法6.8-6.9最小生成树

第1关：算法6.8 prim算法

任务描述

本关任务：编写一个最小生成树的prim算法，采用邻接矩阵表示图。

编程要求

根据提示，在右侧编辑器补充代码，输出最小生成树中的边。

输入输出说明

输入说明：第一行为顶点数n和边数e 第二行为n个顶点符号接下来e行为e条边，每行前两个字符代表无向图的一条边，第三个表示边权。

输出说明：最小生成树中的边

测试说明

平台会对你编写的代码进行测试：

测试输入：

6 10

a b c d e f

a b 6

a c 5

a d 1

c d 5

b d 5

b e 3

d e 6

e f 6

d f 4

c f 2

测试输出：

边 a--->d

边 d--->f

边 f--->c

边 d--->b

边 b--->e

参考代码

//算法6.8　普里姆算法
#include <iostream>
#include <algorithm>
#include <map>
#include <cmath>
#include <cstring>#define IOS std::ios::sync_with_stdio(false)
//#define YES cout << "1"
//#define NO cout << "0"
#define MaxInt 0x3f
#define MVNum 100
#define OK 1
#define ERROR -1const int N = 1003;using namespace std;
typedef long long LL;typedef char VerTexType;
typedef int ArcType;//辅助数组的定义，用来记录从顶点集U到V-U的权值最小的边
struct edge{VerTexType adjvex;                      //最小边在U中的那个顶点ArcType lowcost;                       //最小边上的权值
}closedge[MVNum];//- - - - -图的邻接表存储表示- - - - -
typedef char VerTexType;                    //假设顶点的数据类型为字符型
typedef int ArcType;                        //假设边的权值类型为整型
typedef struct{ VerTexType vexs[MVNum];                 //顶点表 ArcType arcs[MVNum][MVNum];           //邻接矩阵 int vexnum,arcnum;                       //图的当前点数和边数
}AMGraph;int LocateVex(AMGraph G , VerTexType v){//确定点v在G中的位置for(int i = 0; i < G.vexnum; ++i)if(G.vexs[i] == v)return i;return -1;
}//LocateVexvoid CreateUDN(AMGraph &G){ //采用邻接矩阵表示法，创建无向网G int i , j , k;cin >> G.vexnum >> G.arcnum;                            //输入总顶点数，总边数for(i = 0; i < G.vexnum; ++i)   cin >> G.vexs[i];                                    //依次输入点的信息 for(i = 0; i < G.vexnum; ++i)                          //初始化邻接矩阵，边的权值均置为极大值MaxInt for(j = 0; j < G.vexnum; ++j)   G.arcs[i][j] = MaxInt;for(k = 0; k < G.arcnum;++k){                          //构造邻接矩阵 VerTexType v1 , v2;ArcType w;cin >> v1 >> v2 >> w;                               //输入一条边依附的顶点及权值i = LocateVex(G, v1);  j = LocateVex(G, v2);       //确定v1和v2在G中的位置，即顶点数组的下标 G.arcs[i][j] = w;                                  //边<v1, v2>的权值置为w G.arcs[j][i] = G.arcs[i][j];                       //置<v1, v2>的对称边<v2, v1>的权值为w }//for
}//CreateUDN int Min(AMGraph G){int index = -1;int minn = MaxInt;for(int i = 0; i < G.vexnum; i ++)if(minn > closedge[i].lowcost && closedge[i].lowcost != 0){minn = closedge[i].lowcost;index = i;}return index;
}//Minvoid MiniSpanTree_Prim(AMGraph G, VerTexType u){ //无向网G以邻接矩阵形式存储，从顶点u出发构造G的最小生成树T，输出T的各条边  int k = LocateVex(G,u);for(int j = 0; j < G.vexnum; ++ j)if(j != k) closedge[j] = {u, G.arcs[k][j]};closedge[k].lowcost = 0;for(int i=1;i<G.vexnum;++i){k=Min(G);cout<<"边  "<<closedge[k].adjvex<<"--->"<<G.vexs[k]<<endl;closedge[k].lowcost=0;for(int j=0;j<G.vexnum;++j)if(G.arcs[k][j]<closedge[j].lowcost)closedge[j]={G.vexs[k],G.arcs[k][j]};}
}//MiniSpanTree_Prim int main(){AMGraph G;CreateUDN(G);MiniSpanTree_Prim(G , 'a');return 0;
}//main

第2关：算法6.9 kruskal算法

任务描述

本关任务：编写一个最小生成树的kruskal算法，采用邻接矩阵表示图。

编程要求

根据提示，在右侧编辑器补充代码，输出最小生成树中的边。

输入输出说明

输入说明：第一行为顶点数n和边数e 第二行为n个顶点符号接下来e行为e条边，每行前两个字符代表无向图的一条边，第三个表示边权。

输出说明：最小生成树中的边

测试说明

平台会对你编写的代码进行测试：

测试输入：

6 10

a b c d e f

a b 6

a c 5

a d 1

c d 5

b d 5

b e 3

d e 6

e f 6

d f 4

c f 2

测试输出：

a-->d

c-->f

b-->e

d-->f

b-->d

参考代码

//算法6.9　克鲁斯卡尔算法#include <iostream>
using namespace std;typedef char VerTexType;                    //假设顶点的数据类型为字符型
typedef int ArcType;
#define MVNum 100                           //最大顶点数
#define MaxInt 32767                        //表示极大值，即∞//----------------图的邻接矩阵---------------------
typedef struct{ VerTexType vexs[MVNum];                 //顶点表 ArcType arcs[MVNum][MVNum];           //邻接矩阵 int vexnum,arcnum;                       //图的当前点数和边数
}AMGraph;//辅助数组Edges的定义
struct Edges{VerTexType Head;                       //边的始点VerTexType Tail;                      //边的终点ArcType lowcost;                      //边上的权值
}Edge[(MVNum * (MVNum - 1)) / 2];int Vexset[MVNum];                         //辅助数组Vexset的定义int LocateVex(AMGraph G , VerTexType v){//确定点v在G中的位置for(int i = 0; i < G.vexnum; ++i)if(G.vexs[i] == v)return i;return -1;
}//LocateVexvoid CreateUDN(AMGraph &G){ //采用邻接矩阵表示法，创建无向网G int i , j , k;cin >> G.vexnum >> G.arcnum;                        //输入总顶点数，总边数for(i = 0; i < G.vexnum; ++i){   cin >> G.vexs[i];                               //依次输入点的信息 }for(i = 0; i < G.vexnum; ++i)                     //初始化邻接矩阵，边的权值均置为极大值MaxInt for(j = 0; j < G.vexnum; ++j) G.arcs[i][j] = MaxInt; for(k = 0; k < G.arcnum;++k){                       //构造邻接矩阵 VerTexType v1 , v2;ArcType w;cin >> v1 >> v2 >> w;                           //输入一条边依附的顶点及权值i = LocateVex(G, v1);  j = LocateVex(G, v2);   //确定v1和v2在G中的位置，即顶点数组的下标 G.arcs[i][j] = w;                              //边<v1, v2>的权值置为w G.arcs[j][i] = G.arcs[i][j];                   //置<v1, v2>的对称边<v2, v1>的权值为w Edge[k].lowcost = w;Edge[k].Head = v1;Edge[k].Tail = v2;}//for
}//CreateUDN //----------冒泡排序-------------------
void Sort(AMGraph G){int m = G.arcnum - 2;int flag = 1;while((m > 0) && flag == 1){flag = 0;for(int j = 0 ; j <= m ; j++){if(Edge[j].lowcost > Edge[j+ 1].lowcost){flag = 1;VerTexType temp_Head = Edge[j].Head;Edge[j].Head = Edge[j+ 1].Head;Edge[j + 1].Head = temp_Head;VerTexType temp_Tail = Edge[j].Tail;Edge[j].Tail = Edge[j+ 1].Tail;Edge[j + 1].Tail = temp_Tail;ArcType temp_lowcost = Edge[j].lowcost;Edge[j].lowcost = Edge[j+ 1].lowcost;Edge[j + 1].lowcost = temp_lowcost;}//if}//for--m;}//while
}//Sortvoid MiniSpanTree_Kruskal(AMGraph G){ //无向网G以邻接矩阵形式存储，构造G的最小生成树T，输出T的各条边     /*************************Begin******************/
Sort(G);
for(int i=0;i<G.vexnum;i++)Vexset[i]=i;
for(int i=0;i<G.arcnum;i++)
{int v1=LocateVex(G,Edge[i].Head);int v2=LocateVex(G,Edge[i].Tail);int vs1=Vexset[v1];int vs2=Vexset[v2];if(vs1!=vs2){cout<<Edge[i].Head<<"-->"<<Edge[i].Tail<<endl;for(int j=0;j<G.vexnum;j++)if(Vexset[j]==vs2)  Vexset[j]=vs1;}} /*************************End*******************/
}//MiniSpanTree_Kruskalint main(){AMGraph G;CreateUDN(G);MiniSpanTree_Kruskal(G);return 0;
}///main

作者有言

如果感觉博主讲的对您有用，请点个关注支持一下吧，将会对此类问题持续更新……

算法6.7BFS 算法6.8-6.9最小生成树相关推荐

条件随机场(CRF) - 4 - 学习方法和预测算法(维特比算法)
声明: 1,本篇为个人对<2012.李航.统计学习方法.pdf>的学习总结,不得用作商用,欢迎转载,但请注明出处(即:本帖地址). 2,由于本人在学习初始时有很多数学知识都已忘记,所以为了 ...
SURF算法与SIFT算法的性能比较——图像特征点检测与提取算法分析
图像特征点提取算法的算法研究(SURF和SIFT算法) 1. 摘要计算机视觉中,很大一部分研究集中在图像特征提取和特征生成算法上.对图像的优化,不同于一般数学问题的优化方法,图像的优化是对像素点,在 ...
数据结构与算法（5）字符串（BF算法、KMP算法及KMP算法优化）
目录一.BF算法(暴力算法) 二.KMP算法三.KMP算法优化一.BF算法(暴力算法) 一个一个往后匹配,匹配失败继续从母串下一个和头(子串的头)往后继续匹配. 虽然简单,但是需要较多的时间复杂 ...
标准K-means算法的缺陷、K-mean++初始化算法、初始化算法步骤、Kmeans++算法实现
标准K-means算法的缺陷.K-mean++初始化算法.初始化算法步骤.Kmeans++算法实现目录标准K-means算法的缺陷.K-mean&
Apriori算法、FP-Growth算法、顺序分析、PrefixSpan算法
Apriori算法.FP-Growth算法.顺序分析.PrefixSpan算法目录 Apriori算法.FP-Growth算法.顺序分析.PrefixSpan算法 Apriori算法 FP-Grow ...
Java-JVM虚拟机内存垃圾回收机制gc入门：引用类型，对象标记算法，回收算法，常见的 garbage collector
文章目录 GC的优缺点引用的四种类型对象标记算法引用计数法可达性分析法回收算法标记-清除算法(Mark-Sweep) 复制算法标记-整理算法(Mark-Compact) 分代收集算法常 ...
「AI科技」机器学习算法之K-means算法原理及缺点改进思路
https://www.toutiao.com/a6641916717624721933/ 2019-01-03 08:00:00 K-means算法是使用得最为广泛的一个算法,本文将介绍K-mean ...
floyd算法_最短路径的算法：Floyd算法
点击箭头处"蓝色字",关注我们哦!! 算法最短路径的算法-Floyd算法 ● ○ ● Shortest Path Algorithm - Floyd Algorithm ● ○ ...
【算法】模拟退火算法解决TSP问题的matlab实现
[算法]模拟退火算法解决TSP问题的matlab实现参考文章: (1)[算法]模拟退火算法解决TSP问题的matlab实现 (2)https://www.cnblogs.com/wenyehoush ...

算法6.7BFS 算法6.8-6.9最小生成树

算法6.7BFS

第1关：算法6.7 BFS

任务描述

相关知识

编程要求

输入输出说明

测试说明

代码参考

第2关：算法6.7改进邻接表BFS

任务描述

相关知识

编程要求

输入输出说明

测试说明

参考代码

第3关：算法6.7非连通图邻接表BFS

任务描述

相关知识

编程要求

输入输出说明

测试说明

参考代码

算法6.8-6.9最小生成树

第1关：算法6.8 prim算法

任务描述

相关知识

编程要求

输入输出说明

测试说明

参考代码

第2关：算法6.9 kruskal算法

任务描述

相关知识

编程要求

输入输出说明

测试说明

参考代码

作者有言

算法6.7BFS 算法6.8-6.9最小生成树相关推荐

最新文章

热门文章