算法6.10-6.11最短路 6.12 拓扑排序 6.13关键路径 6.14 六度空间
一个不知名大学生，江湖人称菜狗
original author: jacky Li
Email : [email protected]
Time of completion：2022.12.10
Last edited: 2022.12.11
目录
算法6.10-6.11最短路
第1关：算法6.10 Dijkstra最短路径
任务描述
相关知识
编程要求
输入输出说明
测试说明
参考代码
第2关：算法6.11 Floyd
任务描述
相关知识
编程要求
输入输出说明
测试说明
参考代码
算法6.12 拓扑排序
任务描述
编程要求
输入和输出说明
参考代码
6.13关键路径
任务描述
编程要求
输入和输出说明
参考代码
6.14 六度空间
任务描述
编程要求
输入和输出说明
参考代码
作者有言
算法6.10-6.11最短路
第1关：算法6.10 Dijkstra最短路径
任务描述
本关任务：编写一个最短路径的Dijkstra算法，采用邻接矩阵表示图。
相关知识
为了完成本关任务，你需要掌握：1.如何创建邻接矩阵 2.如何编写Dijkstra。
编程要求
根据提示，在右侧编辑器补充代码，输出两个顶点所对应的最短路径。
输入输出说明
输入说明： 第一行为顶点数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 f
测试输出：
a-->d
c-->f
b-->e
d-->f
b-->d
a-->d-->f
参考代码
//算法6.8 普里姆算法
#include
#include
#include 第2关：算法6.11 Floyd
任务描述
本关任务：编写一个最短路径的Floy算法，采用邻接矩阵表示图。
相关知识
为了完成本关任务，你需要掌握：1.如何创建邻接矩阵 2.如何编写Floyd。
编程要求
根据提示，在右侧编辑器补充代码，输出两个顶点所对应的最短路径。
输入输出说明
输入说明： 第一行为顶点数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 f
测试输出：
a-->d-->f
最短路径的长度为：
5
参考代码
//算法6.8 普里姆算法
#include
#include
#include 算法6.12 拓扑排序
任务描述
本关任务：输出有向图的拓扑排序序列。
编程要求
根据提示，在右侧编辑器补充代码，计算并输出有向图的拓扑排序。
输入和输出说明
输入：第一行是顶点数n和弧数e，以空格分开 第二行是n个顶点符号名，以空格分开 接下来e行是每条弧，以空格分开
输出： 如果网中无环，输出拓扑排序序列以逗号分开 否则，输出“网中存在环，无法进行拓扑排序！”
测试输入：
3 3
1 2 3
1 2
1 3
2 3
预期输出：
1 , 2 , 3
参考代码
#include
using namespace std;
#define MVNum 100 //最大顶点数
#define OK 1
#define ERROR 0
typedef char VerTexType;
//- - - - -图的邻接表存储表示- - - - -
typedef struct ArcNode{ //边结点
int adjvex; //该边所指向的顶点的位置
struct ArcNode *nextarc; //指向下一条边的指针
}ArcNode;
typedef struct VNode{
VerTexType data; //顶点信息
ArcNode *firstarc; //指向第一条依附该顶点的边的指针
}VNode, AdjList[MVNum]; //AdjList表示邻接表类型
typedef struct{
AdjList vertices; //邻接表
AdjList converse_vertices; //逆邻接表
int vexnum, arcnum; //图的当前顶点数和边数
}ALGraph;
//- - - - - - - - - - - - - - - -
//- - - - -顺序栈的定义- - - - -
typedef struct{
int *base;
int *top;
int stacksize;
}spStack;
//- - - - - - - - - - - - - - - -
int indegree[MVNum]; //数组indegree存放个顶点的入度
spStack S;
//------------栈的相关操作----------------------
void InitStack(spStack &S){
//初始化栈
S.base = new int[MVNum];
if(!S.base)
exit(1);
S.top = S.base;
S.stacksize = MVNum;
}//InitStack
void Push(spStack &S , int i){
//进栈
if(S.top - S.base == S.stacksize)
return;
*S.top++ = i;
}//Push
void Pop(spStack &S , int &i){
//出栈
if(S.top == S.base)
return;
i = *--S.top;
}//Pop
bool StackEmpty(spStack S){
//判断栈是否为空
if(S.top == S.base)
return true;
return false;
}//StackEmpty
//-------------------------------------------------
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;
}//LocateVex
int CreateUDG(ALGraph &G){
//创建有向图G的邻接表、逆邻接表
int i , k;
cin >> G.vexnum >> G.arcnum; //输入总顶点数，总边数
for(i = 0; i < G.vexnum; ++i){ //输入各点，构造表头结点表
cin >> G.vertices[i].data; //输入顶点值
G.converse_vertices[i].data = G.vertices[i].data;
//初始化表头结点的指针域为NULL
G.vertices[i].firstarc=NULL;
G.converse_vertices[i].firstarc=NULL;
}//for
for(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; //生成一个新的边结点*p1
p2->adjvex=i; //逆邻接点序号为i
p2->nextarc = G.converse_vertices[j].firstarc; G.converse_vertices[j].firstarc=p2;
//将新结点*p1插入顶点vi的边表头部
}//for
return OK;
}//CreateUDG
void FindInDegree(ALGraph G){
//求出各顶点的入度存入数组indegree中
/******************************Begin***********************/
for(int i=0; inextarc;
}
indegree[i] = cnt;
}
/******************************End*************************/
}//FindInDegree
int TopologicalSort(ALGraph G , int topo[]){
//有向图G采用邻接表存储结构
//若G无回路，则生成G的一个拓扑序列topo[]并返回OK，否则ERROR
/******************************Begin***********************/
FindInDegree(G);
int i,m=0;
ArcNode *p;
InitStack(S);
for(i=0;inextarc)
{
int k=p->adjvex;
if(!(--indegree[k])) Push(S,k);
}
}
if(m 6.13关键路径
任务描述
本关任务：输出网的关键路径。
编程要求
根据提示，在右侧编辑器补充代码，计算网的关键路径。
输入和输出说明
输入：第一行是顶点数n和弧数e，以空格分开 第二行是n个顶点符号名，以空格分开 接下来e行是每条弧以及其权值，以空格分开
输出： 如果网中无环，输出关键路径 否则，输出“网中存在环，无法进行拓扑排序！”
测试输入：
3 3
1 2 3
1 2 5
1 3 6
2 3 1
预期输出：
1-->3
1-->2
2-->3
参考代码
//算法6.13 关键路径算法
#include
using namespace std;
#define MVNum 100 //最大顶点数
#define BDNum MVNum * (MVNum - 1) //最大边数
#define OK 1
#define ERROR 0
typedef char VerTexType;
//- - - - -图的邻接表存储表示- - - - -
typedef struct ArcNode{ //边结点
int adjvex; //该边所指向的顶点的位置
int weight; //权值
struct ArcNode *nextarc; //指向下一条边的指针
}ArcNode;
typedef struct VNode{
VerTexType data; //顶点信息
ArcNode *firstarc; //指向第一条依附该顶点的边的指针
}VNode, AdjList[MVNum]; //AdjList表示邻接表类型
typedef struct{
AdjList vertices; //邻接表
AdjList converse_vertices; //逆邻接表
int vexnum, arcnum; //图的当前顶点数和边数
}ALGraph;
//- - - - - - - - - - - - - - - -
//- - - - -顺序栈的定义- - - - -
typedef struct{
int *base;
int *top;
int stacksize;
}spStack;
//- - - - - - - - - - - - - - - -
int indegree[MVNum]; //数组indegree存放个顶点的入度
int ve[BDNum]; //事件vi的最早发生时间
int vl[BDNum]; //事件vi的最迟发生时间
int topo[MVNum]; //记录拓扑序列的顶点序号
spStack S;
//----------------栈的操作--------------------
void InitStack(spStack &S){
//栈的初始化
S.base = new int[MVNum];
if(!S.base)
exit(1);
S.top = S.base;
S.stacksize = MVNum;
}//InitStack
void Push(spStack &S , int i){
//入栈
if(S.top - S.base == S.stacksize)
return;
*S.top++ = i;
}//Push
void Pop(spStack &S , int &i){
//出栈
if(S.top == S.base)
return;
i = *--S.top;
}//Pop
bool StackEmpty(spStack S){
//判断栈是否为空
if(S.top == S.base)
return true;
return false;
}//StackEmpty
//---------------------------------------
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;
}//LocateVex
int CreateUDG(ALGraph &G){
//创建有向图G的邻接表、逆邻接表
int i , k;
cin >> G.vexnum >> G.arcnum; //输入总顶点数，总边数
for(i = 0; i < G.vexnum; ++i){ //输入各点，构造表头结点表
cin >> G.vertices[i].data; //输入顶点值
G.converse_vertices[i].data = G.vertices[i].data;
//初始化表头结点的指针域为NULL
G.vertices[i].firstarc=NULL;
G.converse_vertices[i].firstarc=NULL;
}//for
for(k = 0; k < G.arcnum;++k){ //输入各边，构造邻接表
VerTexType v1 , v2;
int i , j , w;
cin >> v1 >> v2 >> w; //输入一条边依附的两个顶点
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->weight = w;
//将新结点*p1插入顶点vi的边表头部
ArcNode *p2=new ArcNode; //生成一个新的边结点*p1
p2->adjvex=i; //逆邻接点序号为i
p2->nextarc = G.converse_vertices[j].firstarc; G.converse_vertices[j].firstarc=p2;
p2->weight = w;
//将新结点*p1插入顶点vi的边表头部
}//for
return OK;
}//CreateUDG
void FindInDegree(ALGraph G){
//求出各顶点的入度存入数组indegree中
int i , count;
for(i = 0 ; i < G.vexnum ; i++){
count = 0;
ArcNode *p = G.converse_vertices[i].firstarc;
if(p){
while(p){
p = p->nextarc;
count++;
}
}//if
indegree[i] = count;
}//for
}//FindInDegree
int TopologicalOrder(ALGraph G , int topo[]){
//有向图G采用邻接表存储结构
//若G无回路，则生成G的一个拓扑序列topo[]并返回OK，否则ERROR
int i , m;
FindInDegree(G); //求出各顶点的入度存入数组indegree中
InitStack(S); //栈S初始化为空
for(i = 0; i < G.vexnum; ++i)
if(!indegree[i]) Push(S, i); //入度为0者进栈
m = 0; //对输出顶点计数，初始为0
while(!StackEmpty(S)){ //栈S非空
Pop(S, i); //将栈顶顶点vi出栈
topo[m]=i; //将vi保存在拓扑序列数组topo中
++m; //对输出顶点计数
ArcNode *p = G.vertices[i].firstarc; //p指向vi的第一个邻接点
while(p){
int k = p->adjvex; //vk为vi的邻接点
--indegree[k]; //vi的每个邻接点的入度减1
if(indegree[k] ==0) Push(S, k); //若入度减为0，则入栈
p = p->nextarc; //p指向顶点vi下一个邻接结点
}//while
}//while
if(m < G.vexnum) return ERROR; //该有向图有回路
else return OK;
}//TopologicalOrder
int i,k,e,l,j;
int CriticalPath(ALGraph G){
//G为邻接表存储的有向网，输出G的各项关键活动
int i,k,j;
ArcNode *p;
//G为邻接表存储的有向网，输出G的各项关键活动
if (!TopologicalOrder(G, topo)) return ERROR;
//调用拓扑排序算法，使拓扑序列保存在topo中，若调用失败，则存在有向环
int n = G.vexnum; //n为顶点的个数
for (i = 0;i < n;i++) //给每个事件的最早发生时间置初值为0
ve[i] = 0;
/*按照拓扑次序求每个事件的最早发生时间*/
for (i = 0;i < n;i++) //for循环结束才能求得最早发生时间
{
k = topo[i]; //取得拓扑序列中的顶点序号k
p = G.vertices[k].firstarc; //p指向k的第一个邻接点
while (p != NULL) //依次更新k的所有邻接顶点的最早发生时间
{
j = p->adjvex; //j为邻接顶点的序号
if (ve[j] < ve[k] + p->weight) //更新顶点j的最早发生时间ve[j]
ve[j] = ve[k] + p->weight;
p = p->nextarc; //p指向k的下一个邻接顶点
}
}
for (i = 0;i < n;i++) //给每个事件的最迟发生时间置初值为ve[n-1]
vl[i] = ve[n - 1];
/*按逆拓扑次序求每个事件的最迟发生时间*/
for (i = n - 1;i >= 0;i--)
{
k = topo[i]; //取得拓扑序列中的顶点序号k
ArcNode* p = G.vertices[k].firstarc; //p指向k的第一个邻接顶点
while (p != NULL)
{ //根据k的邻接点，更新k的最迟发生时间
j = p->adjvex; //j为邻接顶点的序号
if (vl[k] > vl[j] - p->weight) //更新顶点k的最迟发生时间vl[k]
vl[k] = vl[j] - p->weight;
p = p->nextarc; //p指向下一个邻接顶点
}
}
/*判断每一活动是否为关键活动*/
for (i = 0;i < n;i++)
{ //每次循环针对vi为活动开始点的所有活动
p = G.vertices[i].firstarc; //p指向i的第一个邻接顶点
while (p != NULL)
{
j = p->adjvex; //j为i的邻接顶点的序号
e = ve[i]; //计算活动的最早开始时间
l = vl[j] - p->weight; //计算活动的最迟开始时间
if (e == l) //若为关键活动，输出
cout<"<nextarc; //p指向i的下一个邻接顶点
}
}
}//CriticalPath
int main(){
ALGraph G;
CreateUDG(G);
int *topo = new int [G.vexnum];
if(!CriticalPath(G))
cout << "网中存在环，无法进行拓扑排序！" << endl;
cout << endl;
return OK;
}//main
6.14 六度空间
任务描述
本关任务：验证六度空间理论。
编程要求
根据提示，在右侧编辑器补充代码，计算从顶点0出发，长度不超过7的路径百分比。
输入和输出说明
输入：第一行是顶点数n和边数e，以空格分开
接下来`$$e$$`行是每条边
输出： 定点长度不超过7的路径百分比，以小数代表，保留6位小数。
测试输入：
10 9
0 1
1 2
2 3
3 4
4 5
5 6
6 7
7 8
8 9
预期输出：
0.800000
参考代码
#include
#include
#include
#include
using namespace std;
vector g[1003];
int n,m,num,i,visit[1003]={0};
void makeg(){ //构成临界矩阵。
int x,y;
for(i=0;i q;
q.push(x);
visit[x] = 1, num ++;
for(int deep = 0; deep < 7; deep ++)
{
vector t; //设置一个数组来静态存储当前层次待遍历用户，若用队列存储的话，需要一个当前层次队列，以及待遍历的下一层次队列，完成后涉及到队列的交替转换，难以实现。
while(!q.empty())
{
int temp=q.front();
q.pop();
t.push_back(temp);
}
for(i = 0; i < t.size(); i ++)
{
int k = t[i];
for(int j = 0; j < g[k].size(); j ++)
{
int temp = g[k][j];
if(visit[temp]==0)
{
visit[temp]=1, num++;
q.push(temp);
}
}
}
}
}
int main(){
scanf("%d %d",&n,&m);
makeg();
num=0;
fill(visit,visit+n+1,0); //由于是1-n编号，此处要初始化到visit+n+1；
BFS(0);
printf("%f\n",double(num)/(double)n);
return 0;
} 作者有言
如果感觉博主讲的对您有用，请点个关注支持一下吧，将会对此类问题持续更新……