回溯法、分支限界法解决旅行商TSP问题

最新推荐文章于 2024-05-04 16:09:13 发布
最新推荐文章于 2024-05-04 16:09:13 发布
阅读量1.6w 收藏 152
点赞数 11
分类专栏： 算法作业 文章标签： 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42295427/article/details/104106468
版权

文章目录

TSP问题描述

旅行商从驻地出发，经过每个需要访问的城市一次且只有一次，并最终返回出发点。如何安排路线，使旅行总路程最短？即求解最短哈密顿回路。
在这里插入图片描述

回溯法解tsp问题（深度优先）

以深度优先的方式，从根节点开始，依次扩展树节点，直到达到叶节点——搜索过程中动态产生解空间
在这里插入图片描述

代码

#include<stdio.h>
#include<time.h>
#include<stdlib.h>
#define NUM 42
#define NoEdge 99999
struct  MinHeapNode{//解空间树的节点
	double lb,//子树费用的下界 
	cc;//当前费用 
	int s,
	*x;
	struct MinHeapNode *next;
};
int bestx[NUM+1];//最优路径
int x[NUM+1];
double cw=0.0,bestw=99999.0;//cw是当前路径值，bestw是最优路径值
double **w;//距离矩阵
int count=0;//计算节点数
MinHeapNode* head = 0; /*堆头*/
MinHeapNode* fq = 0; /*堆第一个元素*/
MinHeapNode* lq = 0; /*堆最后一个元素*/
void swap(int i,int j){//用于交换
	int temp=x[i];
	x[i]=x[j];
	x[j]=temp;
}

void backtrackTSP(int i,int n){//回溯法求解
	count++; 
	if(i==n){//到达叶节点
		if(w[x[n-1]][x[n]]!=99999&&w[x[n]][x[1]]!=99999){//叶节点的父节点和叶节点是否有路径，叶节点和第一个节点是否有路径
			if(cw+w[x[n-1]][x[n]]+w[x[n]][x[1]]<bestw){//当前路径值是否会优于当前最优值
				bestw=cw+w[x[n-1]][x[n]]+w[x[n]][x[1]];
				for(int j=1;j<=n;j++)
					bestx[j]=x[j];
			}
		}
	}
	else{//非叶节点
		for(int j=i;j<=n;j++){
			if(w[x[i-1]][x[j]]!=99999&&cw+w[x[i-1]][x[j]]<bestw){//若当前节点到下一节点无路径或当前路径值已经大于当前最优值，进行剪枝
				swap(i,j);
				cw=cw+w[x[i-1]][x[i]];
				backtrackTSP(i+1,n);
				//回溯失败 
				cw=cw-w[x[i-1]][x[i]];
				swap(i,j);
			}
		}
	}
}

int main(){
	FILE* fp1=fopen("22基站.txt","r");
	FILE* fp2=fopen("15基站.txt","r");
	FILE* fp3=fopen("20基站.txt","r");
	FILE* fp4=fopen("30基站.txt","r");
	w=(double**)malloc(sizeof(double*)*(NUM+1));
	for(int i=0;i<=NUM;i++)
		w[i]=(double*)malloc(sizeof(double)*(NUM+1));
	
	for(int i=1;i<=22;i++)//读入22基站的连接矩阵 
		for(int j=1;j<=22;j++)
			fscanf(fp1,"%lf",&w[i][j]);
	for(int i=1;i<=15;i++)//读入15个基站的初始顺序 
		fscanf(fp2,"%d",&x[i]);
	backtrackTSP(2,15);
	printf("%lf\n",bestw);
	for(int i=1;i<=15;i++)
		printf("%d ",bestx[i]);
	printf("\n%d\n",count);
	count=0;
	
	cw=0.0;
	bestw=99999.0;	
	for(int i=1;i<=20;i++)//读入20个基站的初始顺序 
		fscanf(fp3,"%d",&x[i]);
	backtrackTSP(2,20);
	printf("%lf\n",bestw);
	for(int i=1;i<=20;i++)
		printf("%d ",bestx[i]);
	printf("\n%d\n",count);
}

基站数据

在这里插入图片描述

运行结果

在这里插入图片描述

分支限界法解tsp问题（广度优先）

在这里插入图片描述

代码

#include<stdio.h>
#include<time.h>
#include<stdlib.h>
#define NUM 42
#define NoEdge 99999
struct  MinHeapNode{
	double lb,//子树费用的下界 
	cc;//当前费用 
	int s,
	*x;
	struct MinHeapNode *next;
};
int bestx[NUM+1];
int x[NUM+1];
double cw=0.0,bestw=99999.0;
double **w;
double upcost=0.0;//问题的上界 
MinHeapNode* head = 0; /*堆头*/
MinHeapNode* fq = 0; /*堆第一个元素*/
MinHeapNode* lq = 0; /*堆最后一个元素*/

void swap(int i,int j){
	int temp=x[i];
	x[i]=x[j];
	x[j]=temp;
}

int DeleteMin(MinHeapNode*&E)//从堆中取出下一个节点
{
	MinHeapNode* tmp = NULL;
	tmp = fq;
	// w = fq->weight ;
	E = fq;
	if(E == NULL)
		return 0;
	head->next = fq->next; /*一定不能丢了链表头*/
	fq = fq->next;
 	//free(tmp) ;
	return 0;
}

int Insert(MinHeapNode* hn)//在堆中插入节点
{
	if(head->next == NULL)
	{
		head->next = hn; //将元素放入链表中
		fq = lq = head->next; //一定要使元素放到链中
	}else
	{
		MinHeapNode *tmp = NULL;
		tmp = fq;
		if(tmp->lb > hn->lb)
		{
			hn->next = tmp;
			head->next = hn;
			fq = head->next; 
		}else
		{
			for(; tmp != NULL;)
			{
				if(tmp->next != NULL && tmp->next->lb > hn->lb)
				{
					hn->next = tmp->next;
					tmp->next = hn;
					break;
				}
				tmp = tmp->next;
			}
		}
		if(tmp == NULL)
		{
			lq->next = hn;
			lq = lq->next;
		}
	}
	return 0;
}

void up_cost(int k,int n){//用于求解问题上界 
	//贪心法+回溯法求解问题上界
	//printf("beging:%d\n",k);
	if(k==n){
		if(w[x[k]][x[1]]!=NoEdge){
			flag=1;
			upcost=cw+w[x[k]][x[1]];
		}
	}
	else{
		for(int i=0;i<n-k-1;i++){//冒泡排序 
			for(int j=k+1;j<n-i;j++){
				if(w[x[k]][x[j]]>w[x[k]][x[j+1]])
					swap(j,j+1);
			}
		}
		for(int i=k+1;i<=n;i++){
			if(flag==1)
				break;
			if(w[x[k]][x[i]]!=NoEdge){
				//printf("%d,%d,%lf\n",x[k],x[i],w[x[k]][x[i]]);
				cw+=w[x[k]][x[i]];
				swap(k+1,i);
				up_cost(k+1,n);
				cw-=w[x[k]][x[k+1]];//失败回溯 
				swap(k+1,i);
			}		
		}
	}
}

void low_cost(MinHeapNode *p,int n){//用于求解问题下界 
	p->lb=0.0;
	p->lb+=2*p->cc;//已经经过的路径总长的两倍
	double min=NoEdge;
	int min1;
	/*//从当前已经走过的第一个城市出发，走向最近的1个未遍历城市的距离和
	for(int j=p->s+1;j<n;j++){
		if(w[p->x[0]][p->x[j]]<min)
			min=w[p->x[0]][p->x[j]];
	}
	p->lb+=min;
	min=NoEdge;*/
	for(int i=p->s+1;i<n;i++){//进入/离开未遍历城市时，各未遍历城市带来的最小路径成本
		for(int j=0;j<n;j++){
			if(w[p->x[i]][p->x[j]]<min){
				min=w[p->x[i]][p->x[j]];
				min1=j;
			}		
		}
		p->lb+=min;
		min=NoEdge;
		for(int j=0;j<n;j++){
			if(w[p->x[i]][p->x[j]]<min&&j!=min1)
				min=w[p->x[i]][p->x[j]];
		}
		p->lb+=min;
		min=NoEdge;
	}
	p->lb/=2;
	
	if(p->s==n-1)
		p->lb+=w[p->x[n-1]][p->x[0]];
	else{
		//从当前已经走过的第一个城市出发，走向最近的1个未遍历城市的距离和
		for(int j=p->s+1;j<n;j++){
			if(w[p->x[0]][p->x[j]]<min)
				min=w[p->x[0]][p->x[j]];
		}
		p->lb+=min;
		min=NoEdge;
	}
	
	/*for(int i=0;i<n;i++)
		printf("%d ",p->x[i]);
	printf("\n%lf\n",p->lb);*/
}

void BBTSP(int v[],int n)//回溯法求解
{//解旅行售货员问题的优先队列式分支限界法
	/*初始化最优队列的头结点*/
	head = (MinHeapNode*)malloc(sizeof(MinHeapNode));
	head->cc = 0;
	head->x = 0;
	head->lb = 0;
	head->next = NULL;
	head->s = 0;

	MinHeapNode *E ;
	E = (MinHeapNode*)malloc(sizeof(MinHeapNode));
	E->x = new int[n];
	for(int i = 0; i <n; i++)
		E->x[i] = x[i+1];
		
	E->s = 0;
	low_cost(E,n);
	E->cc = 0;
	E->next = NULL; //初始化当前扩展节点
	//搜索排列空间树
	while(E->s >=0)
	{//非叶结点
		//printf("s:%d\n",E->s);
		//printf("chuli:%d\n",E->x[E->s]);
		//printlen();
		//printf("-------s:%d---------\n",E->s);
		if(E->s == n - 1)//到达叶节点 
		{
			/*
			如果该叶结点的路径值和所有节点的lb相比是最小的，输入最优解算法结束
			否则更新上界 
			*/
			/*printf("!!!!!!\n");
			for(int k=0;k<n;k++)
				printf("%d ",E->x[k]);
			printf("\n");*/
			if(w[E->x[E->s]][E->x[0]]==NoEdge){//无法形成回路
				//printf("11111\n"); 
				DeleteMin(E);
				continue;
			}
			else{
				E->cc+=w[E->x[E->s]][E->x[0]];
				bestw=E->cc;
				for(int i=0;i<n;i++)
					bestx[i+1]=E->x[i];
				break;
			}
				
		}else
		{/*扩展子节点，将可行子节点加入优先队列中*/
			//printf("2,upcost:%lf\n",upcost);
			for(int i = E->s + 1; i < n; i++)
				if(w[E->x[E->s]][E->x[i]] != NoEdge)
				{ /*当前扩展节点到其他节点有边存在*/
					//可行儿子结点
					//printf("3\n");
					double cc = E->cc + w[E->x[E->s]][E->x[i]]; /*加上节点i后当前节点路径*/
					MinHeapNode* N;
					N = (MinHeapNode*)malloc(sizeof(MinHeapNode));
					N->x = new int[n];
					for(int j = 0; j < n; j++)
						N->x[j] = E->x[j];
					N->x[E->s + 1] = E->x[i];
					N->x[i] = E->x[E->s + 1];
					N->cc = cc; /*更新当前路径距离*/
					N->s = E->s + 1; /*更新当前节点*/
					low_cost(N,n);
					//printf("cc:%lf\n",N->cc);
					//printf("lb:%lf\n",N->lb);
					if(N->lb<=upcost)
					{//子树可能含最优解,结点插入最小堆
						/*添加当前路径*/
						//printf("add:%d\n",N->x[E->s+1]);
						//printf("4\n");
						N->next = NULL;
						Insert(N); /*将这个可行儿子结点插入到活结点优先队列中*/
					}
				}
			free(E);
		}//完成结点扩展
		DeleteMin(E);//取下一扩展结点
		if(E == NULL)
			break; //堆已空
	}

	if(bestw == NoEdge)
		return ;//无回路
	while(true)
	{//释放最小堆中所有结点
		free(E->x);
		DeleteMin(E);
		if(E == NULL)
			break;
	}
}

int main(){
	FILE* fp1=fopen("22基站.txt","r");
	FILE* fp2=fopen("15基站.txt","r");
	FILE* fp3=fopen("20基站.txt","r");
	FILE* fp4=fopen("30基站.txt","r");
	w=(double**)malloc(sizeof(double*)*(NUM+1));
	for(int i=0;i<=NUM;i++)
		w[i]=(double*)malloc(sizeof(double)*(NUM+1));
	
	for(int i=1;i<=22;i++)//读入22基站的连接矩阵 
		for(int j=1;j<=22;j++)
			fscanf(fp1,"%lf",&w[i][j]);
			
	for(int i=1;i<=15;i++)//读入15个基站的初始顺序 
		fscanf(fp2,"%d",&x[i]);

	
	up_cost(1,15);//求问题上界 
	cw=0.0;
	printf("upcost:%lf\n",upcost); 
	BBTSP(bestx,15);
	//backtrackTSP(2,15);
	printf("最优值：%lf\n",bestw);
	printf("最优路径："); 
	for(int i=1;i<=15;i++)
		printf("%d ",bestx[i]);
	
	cw=0.0;
	bestw=99999.0;
	for(int i=1;i<=20;i++)//读入20个基站的初始顺序 
		fscanf(fp3,"%d",&x[i]);
	up_cost(1,20);//求问题上界
	cw=0.0;
	printf("\nupcost:%lf\n",upcost);
	BBTSP(bestx,20);
	printf("最优值：%lf\n",bestw);
	printf("最优路径："); 
	for(int i=1;i<=20;i++)
		printf("%d ",bestx[i]);

}

运行结果

在这里插入图片描述

结果分析

明显可以看出分支限界法求解所用的时间是少于回溯法的，毕竟前者设计上便是以空间换时间。回溯法的时间复杂度是 O ( n ! ) O(n!) O(n!)，而分支限界法的时间复杂度是 O ( n 2 × 2 n ) \mathrm{O}\left(n^{2} \times 2^{n}\right) O(n2×2n)

qq_虚无
关注
  • 11
    点赞
  • 踩
  • 152
    收藏
    觉得还不错? 一键收藏
  • 4
    评论
专栏目录
分支限界法求解旅行商问题
hgqqtql的专栏
03-06 1万+
问题来来自2016华为软件精英挑战赛。  问题定义 给定一个带权重的有向图G=(V,E)，V为顶点集，E为有向边集，每一条有向边均有一个权重。对于给定的顶点s、t，以及V的子集V'，寻找从s到t的不成环有向路径P，使得P经过V'中所有的顶点(对经过V'中节点的顺序不做要求)。 若不存在这样的有向路径P，则输出无解，程序运行时间越短，则视为结果越优；若存在这样的有向路径P，则输出所得到的路径，
回溯法和分支限界法解决旅行商问题
qq_43717119的博客
10-28 9787
实验三 旅行商问题一. 实验内容二．实验目的三. 算法描述1、回溯算法描述：2、分支限界法算法描述：四. 算法实现1.数据结构及函数说明（1） 回溯法求解TSP问题（2） 分支界限求解TSP问题：2.源程序代码（1）回溯法求解TSP问题源代码：（2）分支界限求解TSP问题五．程序运行结果（1） 回溯法求解TSP问题运行结果：（2） 分支界限求解TSP问题运行结果六．实验结果分析七．结论 一. 实验内容 运用分别编程实现回溯法和分支限界法求 TSP 问题的最优解，分析比较两种算法的时间复杂度并验证分析结果。
分支定界求解TSP问题
05-08
支限界法类又称为剪枝限界法或分支定界法，它类似于回溯法，也是一种在问题的解空间树T上搜索问题解的算法。它与回溯法有两点不同：①回溯法只通过约束条件剪去非可行解，而分支限界法不仅通过约束条件，而且通过目标函数的限界来减少无效搜索，也就是剪掉了某些不包含最优解的可行解。②在解空间树上的搜索方式也不相同。回溯法以深度优先的方式搜索解空间树，而分支限界法则以广度优先或以最小耗费优先的方式搜索解空间树。分支限界法的搜索策略是：在扩展结点处，先生成其所有的儿子结点（分支），然后再从当前的活结点表中选择下一个扩展结点。为了有效地选择下一扩展结点，以加速搜索的进程， 在每一活结点处，计算一个函数值（限界），并根据这些已计算出的函数值，从当前活结点表中选择一个最有利的结点作为扩展结点，使搜索朝着解空间树上有最优解的分支推进，以便尽快地找出一个最优解。 从活结点表中选择下一扩展结点的不同方式导致不同的分支限界法。最常见的有以下两种方式： ①队列式(FIFO)分支限界法：队列式分支限界法将活结点表组织成一个队列，并按队列的先进先出原则选取下一个结点为当前扩展结点。 ②优先队列式分支限界法：优先队列式分支限界法将活结点表按照某个估值函数C(x)的值组织成一个优先队列，并按优先队列中规定的结点优先级选取优先级最高的下一个结点成为当前扩展结点。 影响分支限界法搜索效率的有两个主要因素：一是优先队列Q的优先级由C(x)确定，它能否保证在尽可能早的情况下找到最优解，如果一开始找到的就是最优解，那么搜索的空间就能降低到最小。二是限界函数u(x)，它越严格就越可能多地剪去分支，从而减少搜索空间。 在用分支限界法解决TSP问题时，有不少很好的限界函数和估值函数已经构造出来出了（限于篇幅，这里不做详细介绍）， 使得分支限界法在大多数情况下的搜索效率大大高于回溯法。但是，在最坏情况下，该算法的时间复杂度仍然是O(n!)，而且有可能所有的(n-1)!个结点都要存储在队列中。 近似算法是指不能肯定找到最优解的算法，但通常找到的也是比较好的解，或称近似最优解。[20]一般而言，近似算法的时间复杂度较低，通常都是多项式时间内的。由于近似算法的时间效率高，所以在实际应用中，主要是使用近似算法，这一类算法也一直是研究的主要对象。传统的近似算法以采用贪心策略和局部搜索为主，而几十年来，随着以遗传算法为代表的新型启发式搜索算法的逐步完善，在解决TSP问题上获得了巨大的成功。遗传算法、模拟退火算法、蚁群算法等已经成为公认的好算法。在本节中，将介绍传统的近似算法。
分支限界法求解TSP问题
最新发布
m0_71835254的博客
05-04 2168
创建的最短路径数组bestd在bfs函数中，是多个相同vno比较，最终bestd为此编号最小数组，在最后的tsp函数中，还需与其他编号进行比较。在二进制中，两个数的按位或操作规则是：只有当两个相应的位都是 0 时，结果位才是 0，否则结果位是 1。广度优先遍历与队列的性质吻合，常见的分支搜索方式有队列式分支限界法和优先队列式分支限界法，本文采用优先队列式分支限界法。优先队列中的比较器问题：根据长度排序规则，返回值>0，排在后面晚出队，返回值<0，排在前面先出队。直接结束当前环节的迭代，跳到下一层迭代。
分枝限界算法解决旅行商问题
07-24
本程序对于想直观了解分支限界算法的程序员们来说是一个很好的东西，它以树形图的方式，展示了排列树中每个节点的入堆出堆情况，并且给出了详细的信息，对理解算法的精髓提供了很好的帮助。
回溯法算法分析，装载问题，n皇后，0-1背包，旅行商问题（TSP）
qq_61219640的博客
03-30 2558
问题分析：首先是棋盘存储的问题，我们不采用二维数组，而是采用一维数组queenx来表示数组，queenx[i]=k,其中i表示第i行，k表示的是列。先逐行遍历，每一行的每一列逐个试探，如果可以摆放继续下一行，如果不可以摆放那么回溯到上一行。由于每次都是按照每一行的每一个位置开始四列的摆放，那么每个节点对应n个扩展，那么解空间树的节点个数为。根据选择树推导，一共有n层，每层相加：1+2+……),由于存在剪枝操作 ，实际运行时要远小于这个时间复杂度。该节点下面的子树不再进行考虑，这也是比暴力枚举优化的地方。
tsp分支限界_回溯法、分支限界法两种思想帮你轻松搞定旅行售货员问题(TSP)
weixin_39725650的博客
11-24 903
问题描述某售货员要到若干城市去推销商品，已知各城市之间的路线(或旅费)。要选定一条从驻地出发，经过每个城市一遍，最后回到驻地的路线，使总的路程(或总旅费)最小。本文只考虑4个城市的情况，下面这个带权图即为问题的转化。由于只有4个城市，如果规定售货员总是从城市1出发，那么依据排列组合可以得到6种不同的旅行方案，比如12341、13241等等。在这些排列组合基础上可以很容易绘制出一棵排列树，也是该问题...
TSP旅行商问题分支限界法和回溯法源码
01-29
TSP旅行商问题分支限界法和回溯法源码 旅行商(TSP)问题 计算复杂性高，NP-hard问题，无有效的（复杂性为多项式级别）的解法 Metric TSP 欧式空间满足三角形关系 应用： 军事、通信、电路板设计、大规模集成...
动态规划法，回溯法，分支限界法求解TSP旅行商问题
11-17
TSP旅行商问题的解决方法 TSP旅行商问题（Traveling Salesman...动态规划法、回溯法和分支限界法都是解决TSP问题的有效方法，每种方法都有其优缺点。在实际应用中，我们可以根据具体情况选择合适的方法来解决TSP问题。
分支限界解决tsp问题
03-16
在TSP问题中，分支限界法通过构建一棵搜索树，逐步枚举所有可能的旅行路径，并在每一步中使用一个下界函数来评估当前解的最优性，如果某个节点的可能解已经被证明不可能优于已找到的最优解，则立即剪枝，不再继续...
分支限界法之旅行售货员问题
12-09
分支限界法应用于旅行售货员问题时，其基本思想是构建一棵搜索树，树的每个节点代表一个部分解决方案，即旅行路线的一部分。从根节点出发，算法沿着树的不同分支探索可能的解决方案。在每一步，算法都会选择当前状态...
使用分支限界法求解tsp问题
11-17
分支限界法（Branch and Bound）是一种系统性的搜索策略，用于求解最优化问题，特别是在组合优化问题中，如旅行商问题（Traveling Salesman Problem, TSP）。TSP 是一个经典的问题，其中旅行商需要访问一系列城市，...
算法实验-TSP问题(分支限界法)
11-20 5589
算法实验-TSP问题(分支限界法)
算法课堂实验报告（五）——python回溯法与分支限界法（旅行商TSP问题）
Campsisgrandiflora的博客
08-27 1万+
python实现回溯法与分支限界 一、开发环境 开发工具：jupyter notebook 并使用vscode，cmd命令行工具协助编程测试算法,并使用codeblocks辅助编写C++程序 编程语言：python3.6 二、实验目标 1．请用回溯法求对称的旅行商问题（TSP问题） 2．请用分支限界法求对称的旅行商问题（TSP问题） 三、实验内容 旅行商问题的简单说明： 旅行商...
TSP问题求解，简单易懂（动态规划法、分支限界法、回溯法）
空名的博客——云深知处
07-09 3657
文章目录1.动态规划法2.分支限界法3.回溯法 **TSP问题：**旅行家要旅行n个城市,每个城市经历且仅经历一次然后回到出发城市，并要求所走的路程最短。 (∞  3  6  75  ∞  2  36  4  ∞  23  7  5  ∞)\begin{pmatrix}\
分支限界法求解旅行商问题(TSP)
热门推荐
xushuo的博客
11-20 2万+
1 实验内容 某售货员要到若干城市去推销商品，已知各城市之间的路程（以耗费矩阵的形式表示）。要求使用分支限界算法，求得一条回路，该回路经过每个城市一次，且总的耗费（总距离）最小。 2 算法思路 分支限界法是一种在问题的状态空间进行搜索的算法，对于每一个节点算法给出一个界，以x为根的子树生成的节点所表示的解不会超过这个界。在每次扩展时都选择界最优的节点进行扩展。 　　对于旅行商问题，可以按下面的方式组织分支限界算法。 　　在搜索树的组织方面，可以这样考虑。每次选择一个边，左子节点表示使用这条边时的求解状态，
【分支限界法】求解TSP问题
欢迎来到关关雎鸠儿的博客
07-15 2万+
问题描述 TSP问题是指旅行家要旅行n个城市，要求各个城市经历且仅经历一次然后回到出发城市，并要求所走的路程最短。 求解思路   采用贪心法求得近似解为1→3→5→4→2→1，其路径长度为1+2+3+7+3=16，这可以作为TSP问题的上界。   把矩阵中每一行最小的元素相加，可以得到一个简单的下界，其路径长度为1+3+1+3+2=10，但是还有一个信...
使用动态规划、回溯法和分支限界法解决TSP问题
"这篇报告介绍了如何使用动态规划法、回溯法和分支限界法解决TSP旅行商问题。旅行商问题是一个经典的组合优化问题，目标是找到访问所有城市的最短路径并返回起点。报告作者辛瑞乾在2015年提交了这份实验报告，由指导...
评论 4
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值