【数据结构】实验十一：图

news2024/11/17 11:31:27

实验十一 图

一、实验目的与要求

1）掌握图的存储表示与操作实现。

2）掌握图的连通性及其应用。

二、 实验内容

1.用邻接表存储一个图形结构，并计算每个顶点的度。

2. 采用深度和广度优先搜索算法，遍历上述这张图，并输出遍历结果。

三、实验结果

1）请将调试通过的运行结果截图粘贴在下面，并说明测试用例、运行过程和算法步骤。

2）请分析算法的时间复杂度。

3）请将源代码（必要的注释）cpp文件压缩上传（上传附件）。

题目1：

1）

测试用例：

测试用例为总结点数为4、总边数为5的无向图，如下图所示。

运行结果：

运行过程：

通过邻接表创建无向连通图->通过for循环遍历并输出邻接表结果->通过for循环计算并输出各顶点的度数。

2）

算法步骤和时间复杂度分析：

图的邻接表存储类似于树的孩子链表表示法。对于图中每个顶点vi建立一个链表，第i个链表中的结点表示依附于vi的边。每个链表上附设一个头结点和一个尾结点。

假设需要存储的图的顶点数为V，边数为E。如果存储的是无向图，那么遍历时先访问顶点数组的各个元素，再访问其对应的边链表，由于有V个节点，而且无向图的E条边在边链表中会出现两次，即边共出现2E次，所以一共的访问次数为V+2E。因此，算法的时间复杂度为O(|V|+2|E|)。

对于n个顶点无向图的邻接表，顶点vi的度恰为第i个链表中的结点个数。因此可以计算无向图中每个顶点的度。

3）

实验源代码：

#include <iostream>
using namespace std;
#define MVNum 100//最大顶点数 

typedef char VerTexType;//顶点信息
typedef int OtherInfo;//和边相关的信息 

//边结点 
typedef struct ArcNode{
    int adjvex;//该边所指向的顶点的位置 
    struct ArcNode *nextarc;//指向下一条边的指针 
    OtherInfo info;//和边相关的信息
}ArcNode; 

//顶点
typedef struct VNode{ 
    VerTexType data;//顶点信息                 	 
    ArcNode *firstarc;//指向第一条依附该顶点的边的指针 
}VNode, AdjList[MVNum];//AdjList表示邻接表类型 

typedef struct{ 
    AdjList vertices;//邻接表 
    int vexnum, arcnum;//图的当前顶点数和边数 
}ALGraph;

//确定点v在G中的位置
int LocateVex(ALGraph G,VerTexType v){
	for(int i = 0; i < G.vexnum; ++i){
		if(G.vertices[i].data == v){
			return i;//顶点已经存在，返回序号i 
		}
	}
    return -1;
}

//采用邻接表表示法，创建无向图G
void CreateUDG(ALGraph &G){
	int i , k;
	cout <<"请输入总顶点数：";
	cin >> G.vexnum;
	cout <<"请输入总边数：";
	cin >> G.arcnum;
    cout << endl;
	cout << "输入点的名称：" <<endl;
	for(i = 0; i < G.vexnum; ++i){       	
		cout << "请输入第" << (i+1) << "个点的名称:";
		cin >> G.vertices[i].data;//输入顶点值 
		G.vertices[i].firstarc=NULL;//初始化表头结点的指针域为NULL 
    }
	cout << endl;
	cout << "请输入一条边依附的顶点："<<endl;
	for(k = 0; k < G.arcnum;++k){
		VerTexType v1 , v2;//顶点名字 
		int i,j;
		cout << "请输入第" << (k + 1) << "条边依附的顶点:";
		cin >> v1 >> v2;//输入边的两个顶点 
		i = LocateVex(G, v1);//确定第一个点的位置 
		j = LocateVex(G, v2);//确定第二个点的位置
		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的边表头部 
    } 
}

//输出邻接表 
void Show(ALGraph &G){
	cout<<endl;
	int i;
	cout<<endl<<"邻接表为："<<endl; 
	for(i = 0 ; i < G.vexnum ; ++i){
		VNode temp = G.vertices[i];
		ArcNode *p = temp.firstarc;
		if(p == NULL){
			cout << G.vertices[i].data;
			cout << endl;
		}
		else{
			cout << temp.data;
			while(p){
				cout << "->";
				cout << p->adjvex;
				p = p->nextarc;
			}
		}
		cout << endl;
	}
}

//计算度数 
void CountDegree(ALGraph *G){
	cout<<endl;
	int i,j,k,degree;
	int count1=0;
	ArcNode *p;
	for(i=0;i<G->vexnum;i++){
		degree=0;
		p=G->vertices[i].firstarc;
		while(p!=NULL){
			degree++;
			p=p->nextarc ;
		} 
		if(i!=G->vexnum -1){
			cout<<degree<<" ";
		}
		else{
			cout<<degree;
		}
	}
}

int main(){
	ALGraph G;
	CreateUDG(G);
	Show(G);
	cout<<endl<<"各顶点度数依次为："<<endl;
	CountDegree(&G);
	return 0;
}

题目2：

1）

测试用例：

下图所示的总顶点数的9，总边数为10的无向连通图。人为设置从A点开始遍历。

运行结果：

深度优先：

 

 广度优先：

运行过程：

深度优先：

通过邻接表创建无向连通图->输入遍历起点的名称->判断起点是否在无向图内->调用DFS函数进行深度遍历。

广度优先：

通过邻接矩阵和队列创建无向连通图->输入遍历起点的名称->判断起点是否在无向图内->调用BFS函数进行深度遍历。

2）

算法步骤和时间复杂度分析：

深度优先：

假设图的顶点个数为n，边的个数为e。本算法的执行时间主要耗费在递归调用DFS函数上。当访问某顶点时，DFS的执行时间主要耗费在从该顶点出发搜索其所有邻接点上。采用邻接表作为图的存储结构时，对n个顶点访问就需要对所有链表中的e个表结点检查一遍。因此，算法的时间复杂度为O(n+e)。

广度优先：

假设图的顶点个数为n，边的个数为e。本算法对图中的每一个顶点均入队一次。当访问某个顶点时，执行时间主要耗费在从该顶点出发搜索其所有邻接点上。采用邻接矩阵作为图的存储结构时，查找每一个顶点的邻接点所需要的时间为O(n2)。因此，算法的时间复杂度为O(n2)。

3）

实验源代码：

深度优先

//深度优先 
#include <iostream>
#include <cstring>
#include <cstdio>
using namespace std;

#define MVNum 100						
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;                 		//邻接表 
    int vexnum, arcnum;              		//图的当前顶点数和边数 
}ALGraph;

bool visited[MVNum];//访问标志数组，其初值为"false" 

//确定点v在G中的位置
int LocateVex(ALGraph G , VerTexType v){
	for(int i = 0; i < G.vexnum; ++i){
		if(G.vertices[i].data == v){
			return i;
		}
	}
	return -1;
}

//采用邻接表表示法，创建无向图G
void CreateUDG(ALGraph &G){ 
	int i , k;
	cout <<"请输入总顶点数，总边数：";
	cin >> G.vexnum >> G.arcnum;
    cout << endl;
	
	cout << "输入点的名称：" << endl;
    //输入各点，构造表头结点表
	for(i = 0; i < G.vexnum; ++i){          	
		cout << "请输入第" << (i+1) << "个点的名称:";
		cin >> G.vertices[i].data;//输入顶点值 
		G.vertices[i].firstarc=NULL;		
    }
	cout << endl;
    
	cout << "输入边依附的顶点：" << endl;
    //输入各边，构造邻接表
	for(k = 0; k < G.arcnum;++k){        		
		VerTexType v1 , v2;
		int i , j;
		cout << "请输入第" << (k + 1) << "条边依附的顶点:";
		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的边表头部 
    }
}

//深度优先 
void DFS(ALGraph G, int v){        				
	cout << G.vertices[v].data << "->";  
	visited[v] = true;//访问第v个顶点，并置访问标志数组相应分量值为true 
	ArcNode *p = G.vertices[v].firstarc;//p指向v的边链表的第一个边结点 
	//边结点非空
	while(p != NULL){ 
		int w = p->adjvex; //表示w是v的邻接点 
		if(!visited[w]){
			DFS(G, w);//如果w未访问，则递归调用DFS 
		}
		p = p->nextarc;//p指向下一个边结点 
	} 
}

int main(){
	ALGraph G;
	CreateUDG(G);
	cout << endl;
	cout << "无向连通图G创建完成" << endl << endl;

	cout << "请输入遍历连通图的起始点：";
	VerTexType c;
	cin >> c;
	
	int i;
	for(i = 0 ; i < G.vexnum ; ++i){
		if(c == G.vertices[i].data){
			break;
		}
	}
	cout << endl;
	
	while(i >= G.vexnum){
		cout << "该点不存在，请重新输入！" << endl;
		cout << "请输入遍历连通图的起始点：";
		cin >> c;
		for(i = 0 ; i < G.vexnum ; ++i){
			if(c == G.vertices[i].data){
				break;
			}
		}
	}
	cout << "深度优先搜索遍历图结果为：" << endl;
	DFS(G , i);
	return 0;
}

广度优先

//广度优先
#include <iostream>
using namespace std;

#define MVNum 100                       	
#define MAXQSIZE 100					
						
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;

//构造一个空队列Q
void InitQueue(sqQueue &Q){
	Q.base = new ArcType[MAXQSIZE];
	if(!Q.base){
		exit(1);
	}
	Q.front = Q.rear = 0;
}

//插入元素e为Q的新的队尾元素
void EnQueue(sqQueue &Q, ArcType e){
	if((Q.rear + 1) % MAXQSIZE == Q.front){
		return;
	}
	Q.base[Q.rear] = e;
	Q.rear = (Q.rear + 1) % MAXQSIZE;
}

//判断是否为空队
bool QueueEmpty(sqQueue Q){
	if(Q.rear == Q.front){
		return true;
	}
	return false;
}

//队头元素出队 
void DeQueue(sqQueue &Q, ArcType &u){
	u = Q.base[Q.front];
	Q.front = (Q.front + 1) % MAXQSIZE;
}

//确定点v在G中的位置
int LocateVex(Graph G , VerTexType v){
	for(int i = 0; i < G.vexnum; ++i){
		if(G.vexs[i] == v){
			return i;
		}
	}
	return -1;
}

//采用邻接矩阵表示法，创建无向G
void CreateUDN(Graph &G){
	int i , j , k;
	cout <<"请输入总顶点数，总边数：";
    cin >> G.vexnum >> G.arcnum;						
	cout << endl;
	cout << "输入点的名称：" << endl;
    for(i = 0; i < G.vexnum; ++i){   
		cout << "请输入第" << (i+1) << "个点的名称:";
		cin >> G.vexs[i];
	}
	cout << endl;
	//初始化邻接矩阵，边的权值均置为极大值MaxInt
    for(i = 0; i < G.vexnum; ++i)               			 
		for(j = 0; j < G.vexnum; ++j)   
			G.arcs[i][j] = 0; 
	cout << "输入边依附的顶点：" << endl;
	for(k = 0; k < G.arcnum;++k){							
		VerTexType v1 , v2;
		cout << "请输入第" << (k + 1) << "条边依附的顶点:";
		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] = G.arcs[i][j];//置<v1, v2>的对称边<v2, v1>的权值为w 
	}
}

//返回v的第一个邻接点
int FirstAdjVex(Graph G , int v){
	int i;
	for(i = 0 ; i < G.vexnum ; ++i){
		if(G.arcs[v][i] == 1 && visited[i] == false){
			return i;
		}
	}
	return -1;
}

//返回v相对于w的下一个邻接点
int NextAdjVex(Graph G , int u , int w){
	int i;
	for(i = w ; i < G.vexnum ; ++i){
		if(G.arcs[u][i] == 1 && visited[i] == false){
			return i;
		}
	}
	return -1;
}

//按广度优先非递归遍历连通图G
void BFS (Graph G, int v){ 
	sqQueue Q;
	ArcType u;
	ArcType w;
    cout << G.vexs[v] << "->";    
	visited[v] = true;  
    InitQueue(Q);//辅助队列Q  
    EnQueue(Q, v);//v进队 
    while(!QueueEmpty(Q)){
		DeQueue(Q, u);
		for(w = FirstAdjVex(G, u); w >= 0; w = NextAdjVex(G, u, w)){
			//依次检查u的所有邻接点w ，FirstAdjVex(G, u)表示u的第一个邻接点 
			//NextAdjVex(G, u, w)表示u相对于w的下一个邻接点，w≥0表示存在邻接点 
			if(!visited[w]){//w为u的尚未访问的邻接顶点
				cout << G.vexs[w]<<"->";   
				visited[w] = true;
				EnQueue(Q, w);//w进队 
			}
		}
    }
}

int main(){
	Graph G;
	CreateUDN(G);
	cout << endl;
	cout << "无向连通图G创建完成" << endl << endl;
	cout << "请输入遍历连通图的起始点：";
	VerTexType c;
	cin >> c;
	int i;
	for(i = 0 ; i < G.vexnum ; ++i){
		if(c == G.vexs[i]){
			break;
		}
	}
	cout << endl;
	while(i >= G.vexnum){
		cout << "该点不存在，请重新输入！" << endl;
		cout << "请输入遍历连通图的起始点：";
		cin >> c;
		for(i = 0 ; i < G.vexnum ; ++i){
			if(c == G.vexs[i]){
				break;
			}
		}
	}
	cout << "广度优先搜索遍历连通图结果：" << endl;
	BFS(G , i);
	return 0;
}

实验十一 图（2）

一、实验目的与要求

3）掌握最小生成树的概念和算法；

4）掌握最短路径的算法的实现；

5）掌握拓扑排序的应用。

二、实验内容

1.输出所有可能的路径

有n个结点的有向无环图，选取合适的存储方式并找到所有从0到n-1的路径并输出（不要求按顺序）。二维数组的第i个数组中的单元都表示有向图中i号结点所能到达的结点（注：有向图是有方向的，即规定了a→b你就不能从b→a）空就是没有下一个结点了。

示例1：

输入：graph = [[1,2],[3],[3],[]]

输出：[[0,1,3],[0,2,3]]

解释：有两条路径 0 -> 1 -> 3 和 0 -> 2 -> 3

示例2：

输入：graph = [[4,3,1],[3,2,4],[3],[4],[]]

输出：[[0,4],[0,3,4],[0,1,3,4],[0,1,2,3,4],[0,1,4]]

2.建造物流配送中心问题

给定4个城市之间的交通图如下图所示（图中弧上数字表示城市之间的道路长度）。要在4个城市之间选择一个城市建造一个物流配送中心，并使得到物流配送中心最远的城市到物流配送中心的路程最短。

要求：

（1）设计存储结构表示城市及城市之间的关系；

（2）求出物流配送中心最远城市到物流配送中心的最短路程；

（3）分析算法的时间复杂度。

三、实验结果

1）请将调试通过的主要源代码、运行结果截图粘贴在下面，并说明测试用例、运行过程。（必要的注释、Times New Roman 5号，行间距1.5倍）

2）简述算法步骤（选画技术路线图），格式如下：

S1:

S2:

3）请分析算法的时间复杂度。

4）请将源代码（必要的注释）cpp文件一起压缩上传（上传附件）。

题目1：

（1.1）源代码

#include <iostream>
#include <cstdio>
#include <vector>
using namespace std;

//DFS回溯算法——遍历graph[p]，寻找下一个元素，并进行回溯。
void DFS(vector<vector<int> > & graph,vector<int> path,vector<vector<int> >& res,int p){
	int i;
	//在graph[p]中找下一个元素
    for(i=0;i<graph[p].size();i++){
    	//找到最后一个元素，将path加入res
        if(graph[p][i]==graph.size()-1){
            path.push_back(graph.size()-1);
            res.push_back(path);
            path.pop_back();
            continue;
        }
        path.push_back(graph[p][i]);  //不是最后一个元素，继续回溯
        DFS(graph,path,res,graph[p][i]);  //递归调用 
        path.pop_back();
    }
}

//寻找所有到达路径 
vector<vector<int> > allPathsSourceTarget(vector<vector<int> >& graph) {
    vector<vector<int> > res;  //res存储一条路径的所有结点 
    vector<int> path={0};
    DFS(graph,path,res,0);  //调用DFS函数 
    return res;
}

//主函数 
int main() {
	int n;
	cout<<"请输入结点个数：";
	cin>>n;
	vector<vector<int> > store(n);
	cout<<endl<<"请依次输入每个结点的出度以及可达结点的编号："<<endl<<endl;
	for(int i=0;i<n;i++){
		int m;
		cout<<"编号为"<<i<<"的结点的出度：";
		cin>>m;
		cout<<endl<<"该结点可达结点的编号：";
		vector<int> each(m);
		for(int j=0;j<m;j++){
			cin>>each[j];
		}
		cout<<endl;
		store[i]=each;
	}
	vector<vector<int> > res=allPathsSourceTarget(store);
	cout<<endl<<"所有的可能路径如下："<<endl;
	cout<<endl;
	for(int k=0;k<res.size();k++){
		for(int l=0;l<res[k].size();l++){
			if(l==0){
				cout<<res[k][l];
			}
			else{
				cout<<"->"<<res[k][l];
			}
		}
		cout<<endl;
	}
	return 0;
}

（1.2）测试用例

测试用例1：

    如图1所示的4点4边的有向图。寻找0点到3点的所有可能路径。

测试用例2：

    如图2所示的5点8边的有向图。寻找0点到4点的所有可能路径。

（图1）

（图2）

（1.3）运行结果

测试用例1：

测试用例2：

（1.4）运行过程

输入总结点数 -> 输入各结点的出度 -> 输入当前结点可达的结点 -> 调用寻找所有到达路径的函数 -> DFS回溯遍历 -> 输出所有可能的路径。

（2）算法步骤

S1：DFS回溯函数。该函数不仅包含了递归的过程，而且包含了回退的过程。对于一个无向连通图，访问图中某个顶点v0后，然后访问它的某一个邻接顶点v1，然后再从v1出发，访问v1的未访问过的邻接顶点。如此下去，直至到达所有的领接顶点都被访问过。然后回退一步，回到前一次被访问的顶点，看是否还有没有访问的顶点。如果有没有访问的顶点，那么从这个顶点出发，进行向上述的过程一样进行访问；如果无没有访问的顶点，那么再回退一步，进行类似的访问，直至所有的顶点都被访问为止。后续该函数将在寻找所有到达路径函数中被调用。

S2：寻找所有到达路径函数。利用vector<int>向量容器，同时调用DFS回溯函数，将得到的路径结点顺序存储到res数组中，最后返回res数组的结果。后续该函数将在主函数中被调用。

S3：主函数。依次输入结点数、每个结点的出度和当前结点指向的结点，并用数组储存起来。建立起有向图的结构，并明确各个结点之间的连通性。

 

 

（3）算法时间复杂度分析

在遍历有向图时，对于图中每个结点，DFS函数至多调用一次。一旦某个结点被标志为已访问，就不再从当前结点开始进行搜索。对图的遍历实质上是对每个结点查找其邻接点的过程。DFS回溯函数中，使用的是二维数组和向量容器进行存储。因此，查找每个顶点的邻接点所需时间为O(n2)。

因此，本算法的时间复杂度为O(n2)。

题目2：

（1.1）源代码

#include <iostream>
#include <vector>
#define inf 99999
using namespace std;

//邻接矩阵 
int graph[4][4]{
    {0,8,inf,inf},
    {10,0,5,inf},
    {4,inf,0,4},
    {inf,7,3,0},
}; 

int path[4][4]{ 
    {0,1,2,3},
    {0,1,2,3},
    {0,1,2,3},
    {0,1,2,3},
}; 

//最短路径算法 
void solve(int graph[4][4],int path[4][4]){
	int i,j,k;
	for(k=0;k<4;k++) {
        for(i=0;i<4;i++) {
            for(j=0;j<4;j++) {
                if(graph[i][k]+graph[k][j] < graph[i][j]) {
                    graph[i][j] = graph[i][k]+graph[k][j];  //更新最短路径 
                    path[i][j] = path[i][k];
                }
            }
        }
    }
}

//输出邻接矩阵
void Output(int graph[4][4]){
	int i,j;
	for(i=0;i<4;i++){
    	cout<<"[";
    	for(j=0;j<4;j++){
    		if(graph[i][j]==99999){
    			cout<<"inf";
			}
			else{
				cout.width(4);
    			cout<<graph[i][j];
			}
    		if(j!=3){
    			cout<<",";
			}
		}
		cout<<"]\n";
	}
}

//排序最远距离
void Sort(int graph[4][4]){
	int i,j,maxlen[4];//i行j列 
	for(j=0;j<4;j++){
		int maxno=0;
		for(i=0;i<4;i++){
			if(graph[maxno][j]<graph[i][j]){
				maxno=i;
			}
		}
		maxlen[j]=maxno; 
	}
	cout<<"到当前结点最远的距离依次为：";
	for(int k=0;k<4;k++){
		cout<<graph[maxlen[k]][k]<<" ";//第k列的最大数 
	}
	cout<<endl;
	cout<<"其中最小的距离为：";
	int min=graph[maxlen[0]][0],minno=0;
	for(i=1;i<4;i++){
		if(min>graph[maxlen[i]][i]){
			min=graph[maxlen[i]][i];
			minno=i;
		}
	}
	cout<<min<<endl;
	cout<<"所以物流配送中心应该建设的地方为：";
	switch(minno){
		case 0:cout<<"a"<<endl;break;
		case 1:cout<<"b"<<endl;break;
		case 2:cout<<"c"<<endl;break;
		case 3:cout<<"d"<<endl;break;
	}
}

//主函数 
int main() {
	cout<<"初始邻接矩阵:"<<endl; 
	Output(graph);
    solve(graph,path);
    cout<<endl<<"最终邻接矩阵:"<<endl; 
    Output(graph);
    cout<<endl;
    Sort(graph);
    return 0;
}

（1.2）测试用例

测试用例为如下图所示的4点7边的有向图。

预设置的邻接矩阵为：

{0,8,inf,inf}

{10,0,5,inf}

{4,inf,0,4}

{inf,7,3,0}

（1.3）运行结果

（1.4）运行过程

预先设置初始邻接矩阵 -> 输出初始邻接矩阵 -> 将每一个结点进行最小路径函数调用 -> 输出最小路径条件下的邻接矩阵 -> 排序离当前结点的最远距离 -> 寻找最远距离中的最小值和最小值对应的结点并输出。

（2）算法步骤

S0：初始化。预先设置邻接矩阵graph和存储路径的二维数组path。

S1：最短路径算法函数。利用三层for循环，遍历图的所有路径，同时根据判断条件得到当前的最短路径，并更新最短路径，从而使graph中的数据得以更新。

S2：输出邻接矩阵函数。按照矩阵的形式，输出结果最短路径算法更新后的邻接矩阵。

S3：排序最远距离函数。首先通过两层for循环寻找所有结点到当前结点的最远距离，并通过maxlen数组存储。之后通过一层for循环寻找maxlen数组中的最小值，并记录最小值对应的结点序号。最后统一输出每一个结点的最远物流距离，最小的最远物流距离及其对应结点。

S4：主函数。在主函数中依次调用输出邻接矩阵函数（最初的状态）、最短路径算法函数、输出邻接矩阵函数（给每个结点均进行了戴克斯特拉算法的状态）、排序最远距离函数，即可得到物流中心的建设结果和计算分析过程。

（3）算法时间复杂度分析

在最短路径算法函数中，使用了三层for循环来更新最短路径，对于邻接矩阵的每一行而言，耗费的时间为O(n3)。

在排序最远距离函数中，使用了两层for循环来寻找每个结点的最远物流距离，耗费的时间为O(n2)；并使用了一层for循环来寻找最远物流距离中的最小值，耗费的时间为O(n)。

因此，本算法的时间复杂度为O(n3)。

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/804286.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

CSS之允许点击穿透

CSS之允许点击穿透

一、pointer-events 属性用于设置元素是否对鼠标事件做出反应。 二、属性值 三、如果设置点击穿透效果&#xff0c;使用 pointer-events:none; 设置作用元素即可 .your-classname {pointer-events:none; }
阅读更多...
23款奔驰S400豪华型升级后排电动腿托系统，提升后排乘坐舒适性

23款奔驰S400豪华型升级后排电动腿托系统，提升后排乘坐舒适性

奔驰S400L后排座椅是不带腿托和脚托的&#xff0c;也没有一键躺平功能&#xff0c;相对于奔驰S级高配车型上配置的右边老板位座椅&#xff0c;舒适性就差强了一些。
阅读更多...
AX88179A千兆网卡芯片，支持switch联网

AX88179A千兆网卡芯片，支持switch联网

AX88179是世界上第一个USB 3.0&#xff0c;千兆以太网控制器&#xff0c;它在单一芯片上集成了USB 3.0 PHY和10/100/1000Mbps千兆以太网MAC / PHY。AX88179是最新此外ASIX的USB-到-LAN产品组合&#xff0c;提供一个小的形式因素的解决方案和插头-和-打法可用性&#xff0c;使嵌…
阅读更多...
重学C++系列之模板

重学C++系列之模板

一、什么模板 模板的引入跟泛型编程有关&#xff0c;泛型编程指编写和编译时&#xff0c;对于参数的类型是一个不确定的类型&#xff0c;直到程序运行时&#xff0c;才能确定真正的类型。而泛型编程的实现主要通过函数模板和类模板。 二、模板有几种 模板有两种&#xff0c;函…
阅读更多...
无涯教程-jQuery - hide( )方法函数

无涯教程-jQuery - hide( )方法函数

如果显示了 hide()方法&#xff0c;它们只是隐藏每个匹配元素集。此方法还有另一种形式&#xff0c;可以控制动画的速度。 hide( ) - 语法 selector.hide( ); hide( ) - 示例 以下是一个简单的示例&#xff0c;简单说明了此方法的用法- <html><head><title…
阅读更多...
软件测试人员一定要会的用例设计思路

软件测试人员一定要会的用例设计思路

职场新人对测试用例的困惑无非有以下几点 1、什么是测试用例&#xff0c;为什么要写测试用例&#xff1f; 2、不知道怎么写&#xff0c;写了也不知道写的是否完整。 一、什么是测试用例&#xff1f; 百科的释义&#xff1a; 测试用例是对一项特定的软件产品进行测试任务的…
阅读更多...
day45-Netflix Mobile Navigation（左边侧边栏动态导航）

day45-Netflix Mobile Navigation（左边侧边栏动态导航）

50 天学习 50 个项目 - HTMLCSS and JavaScript day45-Netflix Mobile Navigation&#xff08;左边侧边栏动态导航&#xff09; 效果 index.html <!DOCTYPE html> <html lang"en"><head><meta charset"UTF-8" /><meta name&…
阅读更多...
pinia在vue3中的使用

pinia在vue3中的使用

总结&#xff1a; 在store文件夹中建一个pinia的文件userStore.js 1.要想使用pinia必须先引入defineStore 这里我们使用es6的模块化语法导出的 import { defineStore } from pinia 2.然后使用export const useUserStore defineStore(user,{}) defineStore 方法有两个参数&…
阅读更多...
NAT协议（网络地址转换协议）详解

NAT协议（网络地址转换协议）详解

NAT协议&#xff08;网络地址转换协议&#xff09;详解 为什么需要NATNAT的实现方式静态NAT动态NATNAPT NAT技术的优缺点优点缺点 NAT协议是将IP数据报头中的IP地址转换为另外一个IP地址的过程&#xff0c;主要用于实现私有网络访问公有网络的功能。这种通过使用少量的IP地址代…
阅读更多...
机器视觉系统组成，你知道多少？

机器视觉系统组成，你知道多少？

机器视觉系统是一个复杂而高效的技术体系&#xff0c;它的组成主要包括以下几个核心部件&#xff1a; 相机和镜头&#xff1a;相机是机器视觉系统的眼睛&#xff0c;用于捕捉被测物的图像。镜头是相机的重要组成部分&#xff0c;它可以调节焦距、光圈和通光量&#xff0c;帮助获…
阅读更多...
第3章 配置与服务

第3章 配置与服务

1 CoreCms.Net.Configuration.AppSettingsHelper using Microsoft.Extensions.Configuration; using Microsoft.Extensions.Configuration.Json; namespace CoreCms.Net.Configuration { /// <summary> /// 【应用设置助手--类】 /// <remarks> /// 摘要&#x…
阅读更多...
LLVM（2）IR入门

LLVM（2）IR入门

1 不支持类型的隐式转换 int factorial(int val);int factorial(int val) {if (val < 2)return 1;return factorial(val - 1) factorial(val - 2); }int main(int argc, char **argv) {return factorial(2) * 7 42; }生成IR代码 clang -emit-llvm -S t3.cpp -o t3.ll ;…
阅读更多...
Android平台GB28181设备接入侧如何同时对外输出RTSP流？

Android平台GB28181设备接入侧如何同时对外输出RTSP流？

技术背景 GB28181的应用场景非常广泛&#xff0c;如公共安全、交通管理、企业安全、教育、医疗等众多领域&#xff0c;细分场景可用于如执法记录仪、智能安全帽、智能监控、智慧零售、智慧教育、远程办公、明厨亮灶、智慧交通、智慧工地、雪亮工程、平安乡村、生产运输、车载终…
阅读更多...
云原生架构

云原生架构

1. 何为云原生&#xff1f; 很多IT业内小伙伴会经常听到这个名词&#xff0c;那么什么是云原生呢&#xff1f;云原生是在云计算环境中构建、部署和管理现代应用程序的软件方法。 当今时代&#xff0c;众多企业希望构建高度可扩展、灵活且有弹性的应用程序&#xff0c;以便能够快…
阅读更多...
Linux CentOS 8 编译安装Apache Subversion

Linux CentOS 8 编译安装Apache Subversion

前言 距离上一篇发表已经过去了5年零2个多月&#xff0c;这次重新开始写技术博客&#xff0c;理由和原来一样&#xff0c;也就是想把自己学习和工作中遇到的问题和知识记录下来&#xff0c;今天记录一下Linux CentOS 8通过编译安装svn的过程。 下载SVN 下载地址&#xff1a;…
阅读更多...
使用frp中的xtcp映射穿透指定服务实现不依赖公网ip网速的内网穿透p2p

使用frp中的xtcp映射穿透指定服务实现不依赖公网ip网速的内网穿透p2p

使用frp中的xtcp映射穿透指定服务实现不依赖公网ip网速的内网穿透p2p 管理员Ubuntu配置公网服务端frps配置service自启(可选) 配置内网服务端frpc配置service自启(可选) 使用者配置service自启(可选) 效果 通过frp实现内网client访问另外一个内网服务器 管理员 1&#xff09;…
阅读更多...
PHP8的注释-PHP8知识详解

PHP8的注释-PHP8知识详解

欢迎你来到PHP服务网&#xff0c;学习《PHP8知识详解》系列教程&#xff0c;本文学习的是《PHP8的注释》。 什么是注释&#xff1f; 注释是在程序代码中添加的文本&#xff0c;用于解释和说明代码的功能、逻辑或其他相关信息。注释通常不会被编译器或解释器处理&#xff0c;而…
阅读更多...
深度学习实战44-Keras框架下实现高中数学题目的智能分类功能应用

深度学习实战44-Keras框架下实现高中数学题目的智能分类功能应用

大家好，我是微学AI ,今天给大家介绍一下深度学习实战44-Keras框架实现高中数学题目的智能分类功能应用，该功能是基于人工智能技术的创新应用，通过对数学题目进行智能分类，提供个性化的学习辅助和教学支持。该功能的实现可以通过以下步骤：首先，采集大量的高中数学题目数据…
阅读更多...
Clion实现Stm32标准库-HAL库开发配置

Clion实现Stm32标准库-HAL库开发配置

1、配置CLion用于STM32开发&#xff08;基于hal库开发&#xff09; 原文链接 https://zhuanlan.zhihu.com/p/145801160 2、配置CLion用于STM32开发&#xff08;基于标准库开发&#xff09; 参考文章&#xff1a;https://www.bilibili.com/read/cv11442303
阅读更多...
不再困扰！教你如何方便快捷地将文件转换成PDF格式！

不再困扰！教你如何方便快捷地将文件转换成PDF格式！

大家都知道PDF是电脑中最常见且兼容性最好的一种文档文件格式&#xff0c;而这种格式的文件既能保留文档的原始布局&#xff0c;又能够方便阅读和打印。那么&#xff0c;当我们需要将其他格式的文件转换成PDF格式时应该如何处理呢&#xff1f;我们可以使用一款文档转换工具&…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023