C语言 迷宫问题 （广度优先算法）

最新推荐文章于 2022-10-19 16:54:05 发布
最新推荐文章于 2022-10-19 16:54:05 发布
阅读量1.2k 收藏 9
点赞数 4
分类专栏： 笔记 文章标签： 算法 c语言 宽度优先
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u014566150/article/details/121655459
版权

运行结果
本来是想用esayx写的 发现好像用不着，直接改的窗口背景颜色做的，后来还改进了鼠标绘制地图 ，地图大小可以设置，寻路的过程也可以设置放慢的速度，作为大一的一个实践小项目，第一次发csdn，和大家一起分享。

#include<cstdio>
#include<stdlib.h>
#include<windows.h> 
#include<conio.h>

#define RED 	1
#define YELLOW 	21
#define HYELLOW 22
#define GREEN 	3
#define HGREEN  32
#define BLUE 	4
#define PURPLE	5
#define GRAY	6
#define BLACK	7
#define WHITE	8

#define START	1
#define END		-2
#define	WALL	-1
#define WAY		0 

#define YES		1
#define NO		0
#define SLEEPTIME 0
struct Size{//尺寸 
	int width;
	int height;	
};
struct MazeMap{//地图 
	Size size;
	short** EachLine;//该数组存放每一行的头指针 
}; 
struct NodeIndex{//作为坐标标记出入队列 
	int X;
	int Y;
	NodeIndex* nextnode;
};
struct Queue{//链队列 
	NodeIndex* head;
	NodeIndex* tail;
	int num;
};
void InitDataQueue(Queue &indexqueue){//初始化队列 
	indexqueue.head = NULL;
	indexqueue.tail = NULL;
	indexqueue.num = 0;
} 
NodeIndex OutputData(Queue &indexqueue){
	NodeIndex nodeindex;
	NodeIndex* p;
	nodeindex.nextnode = NULL;
	nodeindex.X = -1;
	nodeindex.Y = -1;
	if(indexqueue.num == 0){
		return nodeindex;
	}
	nodeindex = *indexqueue.head;
	p = indexqueue.head->nextnode;
	free(indexqueue.head);
	indexqueue.head = p;
	indexqueue.num--;
	return nodeindex;
}
void InputData(Queue &indexqueue,NodeIndex nodeindex){//尾插法直接数据入队 
	NodeIndex* p;
	p = (NodeIndex*)malloc(sizeof(NodeIndex));
	if(p == NULL){
		printf("系统忙，无法运行\n"); 
		exit(-1);
	}
	*p = nodeindex;
	p->nextnode = NULL;
	if(indexqueue.num == 0){
		indexqueue.tail = p;
		indexqueue.head = indexqueue.tail;
	}else{
		indexqueue.tail->nextnode = p;
		indexqueue.tail = p;
	}
	indexqueue.num++;
}
void InitMazeMap(MazeMap &mazemap,Size size){//初始化地图数据 
	mazemap.size = size;
	mazemap.EachLine = (short**)malloc(sizeof(short*)*size.height);
	if(mazemap.EachLine == NULL){
		printf("系统忙，无法运行\n"); 
		exit(-1);
	}
	short** p,start;
	p = mazemap.EachLine; 
	for(int i=0;i<size.height;i++){
		*p = (short*)malloc(sizeof(short)*size.width);
		if(p == NULL){
			printf("系统忙，无法运行\n"); 
			exit(-1);
		}
		p++;
	}
	short* to_p;
	p = mazemap.EachLine;
	to_p = *p;
	for(int i=0;i<size.height;i++){
		for(int j=0;j<size.width;j++){
			if(i==0 || i==size.height-1 ||j==0 || j==size.width-1){
				*to_p = WALL;
			}else{
				*to_p = WAY;	
			}
			//printf("%d ",*to_p);//调试用于查看数据和数据内存地址 
			to_p++;
		}
		//printf("\n");
		p++;
		to_p = *p;
	}
} 
void GoTo_XY(int x,int y){//移动光标的函数 
	HANDLE handle_out;
	handle_out = GetStdHandle(STD_OUTPUT_HANDLE);
	COORD pos = {x*2,y};
	SetConsoleCursorPosition(handle_out,pos);
}
void Color(int color,HANDLE handle_out){//切换颜色函数 
	switch (color){
		case RED:{
			SetConsoleTextAttribute(handle_out,BACKGROUND_RED|BACKGROUND_INTENSITY ); 
			break;
		}
		case GREEN:{
			SetConsoleTextAttribute(handle_out,BACKGROUND_GREEN); 
			break;
		}
		case HGREEN:{
			SetConsoleTextAttribute(handle_out,BACKGROUND_GREEN|BACKGROUND_INTENSITY); 
			break;
		}
		case BLUE:{
			SetConsoleTextAttribute(handle_out,BACKGROUND_BLUE); 
			break;
		}
		case GRAY:{
			SetConsoleTextAttribute(handle_out,BACKGROUND_RED|BACKGROUND_GREEN|BACKGROUND_BLUE);
			break;
		}
		case PURPLE:{
			SetConsoleTextAttribute(handle_out,BACKGROUND_RED|BACKGROUND_BLUE);
			break;
		}
		case YELLOW:{
			SetConsoleTextAttribute(handle_out,BACKGROUND_RED|BACKGROUND_GREEN);
			break;
		}
		case HYELLOW:{
			SetConsoleTextAttribute(handle_out,BACKGROUND_RED|BACKGROUND_GREEN|BACKGROUND_INTENSITY);
			break;
		}
		case BLACK:{
			SetConsoleTextAttribute(handle_out,BACKGROUND_RED|BACKGROUND_GREEN|BACKGROUND_BLUE|COMMON_LVB_REVERSE_VIDEO);
			break;
		}
		case WHITE:{
			SetConsoleTextAttribute(handle_out,BACKGROUND_RED|BACKGROUND_GREEN|BACKGROUND_BLUE|BACKGROUND_INTENSITY);
			break;
		}
	}
}
POINT GetPosition(){//获取鼠标位置函数 
	POINT pxy ={0,0};
	LPPOINT pxyf = &pxy;
	GetCursorPos(pxyf);
	return pxy;
}
void SetTheWall(MazeMap &mazemap,Size size,HANDLE handle_out,POINT &start,POINT &end){
	int key = 0,Sset = 0,Eset = 0,statue = 1;
	int Rx = 0,Ry = 0;
		GoTo_XY(0,size.height+2);
		Color(WHITE,handle_out);
		printf("操作说明：                       \n");
		printf("1.按下空格的同时移动鼠标绘制地图 \n");
		printf("2.按下P键可以重新定位画笔位置    \n");
		printf("3.按下Enter键结束当前地图绘制    \n");
		printf("4.按下S键设置鼠标当前位置为起点  \n"); 
		printf("5.按下E键设置鼠标当前位置为终点  \n"); 
	POINT pxy ={0,0};
	GoTo_XY(0,0);
	Color(WHITE,handle_out);
	printf("[]<——将鼠标放到框内，双击键盘P键定位鼠标"); 
	fflush(stdin);
	while(_getch() != 112){
		GoTo_XY(0,0);
		printf("[]<——放到这里哦，双击P键定位鼠标				"); 
	}
	while(statue){
		key = _getch();
		pxy = GetPosition();
		switch (key){
			case 32:{//绘制墙体
				pxy.x = (pxy.x-Rx)/16;
				pxy.y = (pxy.y-Ry)/16;
				if(pxy.x<size.width && pxy.y<size.height){
					GoTo_XY(pxy.x,pxy.y);
					mazemap.EachLine[pxy.y][pxy.x] = -1;
					printf("  ");
				}
				break;
			}
			case 114:{//擦除
				pxy.x = (pxy.x-Rx)/16;
				pxy.y = (pxy.y-Ry)/16;
				if(pxy.x>0 && pxy.x<size.width && pxy.y<size.height && pxy.y>0){
					if(mazemap.EachLine[pxy.y][pxy.x] == START){
						Sset = 0;
					}else if(mazemap.EachLine[pxy.y][pxy.x] == END){
						Eset = 0;
					}
					mazemap.EachLine[pxy.y][pxy.x] = 0;
					GoTo_XY(pxy.x,pxy.y);
					Color(GRAY,handle_out);
					printf("  ");
					Color(WHITE,handle_out);
				}
				break;
			}
			case 112:{//鼠标定位 
				Rx = pxy.x;
				Ry = pxy.y;
				break;
			}
			case 115:{//起点绘制 
				if(Sset == 1){
					break;
				}
				pxy.x = (pxy.x-Rx)/16;
				pxy.y = (pxy.y-Ry)/16;
				if(pxy.x<size.width && pxy.y<size.height){
					start.x = pxy.x;
					start.y = pxy.y;
					mazemap.EachLine[pxy.y][pxy.x] = START;
					Color(BLUE,handle_out);
					GoTo_XY(pxy.x,pxy.y);
					printf(" S");
					Color(WHITE,handle_out);
					Sset = 1;
				}
				break;
			}
			case 101:{//终点绘制 
				if(Eset == 1){
					break;
				}
				pxy.x = (pxy.x-Rx)/16;
				pxy.y = (pxy.y-Ry)/16;
				if(pxy.x<size.width && pxy.y<size.height){
					end.x = pxy.x;
					end.y = pxy.y;
					mazemap.EachLine[pxy.y][pxy.x] = END;
					Color(YELLOW,handle_out);
					GoTo_XY(pxy.x,pxy.y);
					printf(" E");
					Color(WHITE,handle_out);
					Eset = 1;
				}
				break;
			}
			case 13:{
				if(Sset && Eset){
					statue = 0;
				}else{
					Color(WHITE,handle_out);
					GoTo_XY(0,0);
					printf("请设置起点终点！");
					Color(WHITE,handle_out);
					_getch(); 
				}
				break;
			}
		} 
		GoTo_XY(0,0);
		printf("[]当前位置：X:%d Y:%d key:%d(画笔不准可放到左边方框重定位)			",pxy.x,pxy.y,key);
	}
}

void PrintMap(MazeMap mazemap,HANDLE handle_out){//显示地图函数 
	Size size = mazemap.size;
	short** p;
	short* to_p;
	p = mazemap.EachLine;
	to_p = *p;
	for(int i=0;i<size.height;i++){
		GoTo_XY(0,i);
		for(int j=0;j<size.width;j++){
			if(*to_p == WAY){
				Color(GRAY,handle_out); 
				printf("  ");
			}else{
				Color(WHITE,handle_out); 
				printf("  ");
			}
			to_p++;
		}
		p++;
		to_p = *p;
	}
} 
void HideCursor(){//隐藏光标 
	CONSOLE_CURSOR_INFO cursor_info = {1,0};//第二个值为零隐藏
	SetConsoleCursorInfo(GetStdHandle(STD_OUTPUT_HANDLE),&cursor_info); 
} 
void SetHandle(HANDLE &handle_out,HANDLE &handle_in,Size size){//获取并设置窗口句柄 
	handle_out = GetStdHandle(STD_OUTPUT_HANDLE);//获得标准输出设备句柄
	handle_in = GetStdHandle(STD_INPUT_HANDLE);
	SMALL_RECT rc = {1,1,size.width*2,size.height+5};//设置窗口位置和大小	
	SetConsoleWindowInfo(handle_out,true,&rc);	//设置窗口信息，第二个参数为设置参数是否执行
}
void SetStartEnd(MazeMap &mazemap,POINT start,POINT end,HANDLE &handle_out){//设置出发点和终点 
	mazemap.EachLine[start.y][start.x] = START;
	Color(BLUE,handle_out);
	GoTo_XY(start.x,start.y);
	printf("S ");
	mazemap.EachLine[end.y][end.x] = END;
	Color(YELLOW,handle_out);
	GoTo_XY(end.x,end.y);
	printf("E ");
} 
int SrcMethod(MazeMap &mazemap,NodeIndex nodeindex,Queue &indexqueue,int drie){//找路的方法 
	int nodevalue = 0;						//Bug(1) [&]
	NodeIndex fblr[4] = {{0,1},{-1,0},{1,0},{0,-1}}; //分别对应上下左右 
	if(mazemap.EachLine[nodeindex.Y+(fblr[drie].Y)][nodeindex.X+(fblr[drie].X)] == END){
		return YES; 
	}
	if(mazemap.EachLine[nodeindex.Y+(fblr[drie].Y)][nodeindex.X+(fblr[drie].X)] == WAY ){
		mazemap.EachLine[nodeindex.Y+(fblr[drie].Y)][nodeindex.X+(fblr[drie].X)] = mazemap.EachLine[nodeindex.Y][nodeindex.X]+1;
		nodeindex.X = nodeindex.X+(fblr[drie].X);
		nodeindex.Y = nodeindex.Y+(fblr[drie].Y);
		GoTo_XY(nodeindex.X,nodeindex.Y);
		printf("  ");
		InputData(indexqueue,nodeindex);
		Sleep(SLEEPTIME);
	}
	return NO;
}
int FindThePeth(MazeMap mazemap,NodeIndex &endindex,NodeIndex &startindex,HANDLE &handle_out){
	int value[4] = {0};
	int i ,min,mark = 0;
	while(true){
		i=0;//(bug_2)注意每次归零，否则有情况不可达 
		value[0] = mazemap.EachLine[endindex.Y][endindex.X+1];//R
		value[1] = mazemap.EachLine[endindex.Y][endindex.X-1];//L
		value[2] = mazemap.EachLine[endindex.Y+1][endindex.X];//F
		value[3] = mazemap.EachLine[endindex.Y-1][endindex.X];//B
		while(value[i]<=0){//既然能够到达，必然有一个可走的（值大于0的点） 
			i++;
		}
		mark = i;
		min = value[i];
		for(i=0;i<4;i++){
			if(value[i] >0 && value[i]<min){
				mark = i;
				min = value[i];
			}
		}
		switch(mark){
			case 0:{
				endindex.X = endindex.X+1;
				break;
			}
			case 1:{
				endindex.X = endindex.X-1;
				break;
			}
			case 2:{
				endindex.Y = endindex.Y+1;
				break;
			}
			case 3:{
				endindex.Y = endindex.Y-1;
				break;
			}
		}
		if(endindex.X == startindex.X && endindex.Y == startindex.Y){
			return YES;
		}
		GoTo_XY(endindex.X,endindex.Y);
		Color(RED,handle_out);
		printf("  ");
		Sleep(SLEEPTIME);
	}
}
void DrawMap(MazeMap &mazemap){//测试用地图绘制 
	 
}
int main(){
	HANDLE handle_out,handle_in;
	MazeMap mazemap;
	Queue indexqueue; 
	Size map_size; 
	
	printf("请输入要生成的地图尺寸：\n");
	printf("宽度（10--50较为适宜）：");
	scanf("%d",&map_size.width); 
	while(map_size.width<10 || map_size.width>50){
		printf("输入数据超出限制，请重新输入");
		scanf("%d",&map_size.width); 
	} 
	printf("高度度（10--50较为适宜）：");
	scanf("%d",&map_size.height ); 
	while(map_size.height<10 || map_size.height>50){
		printf("输入数据超出限制，请重新输入");
		scanf("%d",&map_size.height); 
	}
	POINT start = {0,0};
	POINT end = {0,0}; 
	int srcstatue = NO,nodevalue = 0;
	SetHandle(handle_out,handle_in,map_size);
	HideCursor();
	InitMazeMap(mazemap,map_size);//初始化操作 
	InitDataQueue(indexqueue);
	for(int i=0;i<map_size.height+2;i++){//输出字符固定布局位置，否则拖动窗口大小会被刷新排版 
		GoTo_XY(map_size.width,i);
		Color(BLACK,handle_out);
		printf("|");
	}
	PrintMap(mazemap,handle_out);
	SetTheWall(mazemap,map_size,handle_out,start,end);
	
	NodeIndex nodeindex,startindex,endindex;
	nodeindex.X = start.x;
	nodeindex.Y = start.y; 
	startindex.X = nodeindex.X;
	startindex.Y = nodeindex.Y;
	endindex.X = end.x;
	endindex.Y = end.y;
	InputData(indexqueue,nodeindex);
	while(indexqueue.num != 0){
		nodeindex = OutputData(indexqueue);
		if(nodeindex.X != start.x || nodeindex.Y != start.y){
			Color(HYELLOW,handle_out);
			GoTo_XY(nodeindex.X,nodeindex.Y);
			printf("  ");
			Color(HGREEN,handle_out);	
		}
		if(SrcMethod(mazemap,nodeindex,indexqueue,0) == YES ){
			srcstatue = YES;
			break;
		}
		if(SrcMethod(mazemap,nodeindex,indexqueue,3) == YES ){
			srcstatue = YES;
			break;
		}
		if(SrcMethod(mazemap,nodeindex,indexqueue,2) == YES ){
			srcstatue = YES;
			break;
		}
		if(SrcMethod(mazemap,nodeindex,indexqueue,1) == YES ){
			srcstatue = YES;
			break;
		}
		
		GoTo_XY(0,map_size.height);
		Color(GREEN,handle_out);
		printf("当前可走节点个数：%d		 ",indexqueue.num);
	}
	if(srcstatue==YES){
		FindThePeth(mazemap,endindex,startindex,handle_out);
		GoTo_XY(0,map_size.height+1);
		printf("路径已找到			 ");
	}else{
		GoTo_XY(0,map_size.height+1);
		printf("出口不可达			");
	} 
		
		/*for(int i=0;i<map_size.height;i++){
		for(int j=0;j<map_size.width;j++){
			printf("%2d ",mazemap.EachLine[i][j]);//调试用于查看数据和数据内存地址 
		}
		printf("\n");
		}*/
		
	GoTo_XY(0,map_size.height+5);//运行结束以后恢复位置以及背景 
	Color(BLACK,handle_out);
	CloseHandle(handle_in);
	CloseHandle(handle_out); 
	return 0;
}
DJ老陈头
关注
专栏目录
C语言使用广度优先搜索算法解决迷宫问题（队列）
08-29
C语言使用广度优先搜索算法解决迷宫问题（队列） 本文主要介绍了C语言使用广度优先搜索算法解决迷宫问题的相关知识点，详细解释了C语言队列广度优先搜索算法的使用技巧和实现细节。 一、广度优先搜索算法的基本...
广度优先搜索（迷宫问题）
qq_40810317的博客
03-17 1388
#include &amp;lt;iostream&amp;gt; #include &amp;lt;algorithm&amp;gt; #include &amp;lt;queue&amp;gt; #include &amp;lt;stack&amp;gt; using namespace std; char mp[501][501]; int visit[501][501]={-1}; typedef struct{
迷宫最短路径 广度优先搜索—C
cheryl_77的博客
08-29 947
Bellman-Ford-解决负权边—C
## 基于广度优先搜索及运用队列和栈解决迷宫问题（c语言）
qq_52447813的博客
11-18 2499
基于广度优先搜索及运用队列和栈解决迷宫问题（c语言） 一、迷宫问题： 假设迷宫由m行n列构成，有一个入口和一个出口，入口坐标为（1，1），出口坐标为（m，n），试设计并验证以下算法：找出一条从入口通往出口的路径，或报告一个“无法通过”的信息。 (1) 用C语言实现顺序存储结构上队列的基本操作，然后利用该队列的基本操作找出迷宫的一条最短路径。 (2) 设计一个二维数组MAZE[m+2][n+2]表示迷宫，数组元素为0表示该位置可以通过，数组元素为1表示该位置不可以通行。MAZE[1][1]、MAZE[m][n
广度优先遍历解决迷宫问题
qq_57484399的博客
10-19 2809
我们之前使用深度优先遍历的方法是 , 只派一个人去探索迷宫,记录其路线 和每个节点走过的方向 , 一条道走到黑 , 当路不通时候,回溯到上一个节点 的下一个方向 , 直到这个节点全部方向都遍历完,我们就放弃路线上的这个节点 ,接着回溯到这个节点的上一个节点的另一个方向 , 我们一定可以成功 ,因为我们就算不成功,早晚也可以回溯到起点 ,从起点的下一个方向出发 ,当把所有节点所有方向都遍历完,如果有解, 我们则可以找到出口 , 无解则输出无解 .
迷宫问题c语言广度搜索,迷宫问题Maze (BFS) 广度优先遍历 C语言
weixin_35507450的博客
05-24 368
給你一個迷宮，S為起點，E為終點。請你找出走出迷宮所需要花費的最短步數。你只能往上下左右四個方向移動。输入格式:第一行有一個數字T，代表有T組測資。每組測資的第一行有兩個數字R、C，代表迷宮的大小(R x C)。接下來R行，每行有C個字元來描述迷宮，'.'代表可以行走的路，'X'代表不可行走的牆壁，'S'代表起點，'E'代表終點。測資範圍：T < 1002 < R,C <= 30...
C语言-老鼠走迷宫（广度优先寻路算法）vc6编译
08-22
vc6编译器编译，C语言写的代码，老鼠走迷宫，用广度优先的寻找最短的路径算法，遍历全部路径使用的是深度算法。完整代码可直接下载调试运行。
迷宫问题的算法(优于广度优先,深度优.rar_广度优先_广度优先算法_深度优先_迷宫广度优先_迷宫问题
09-19
本压缩包文件提供了关于解决迷宫问题的算法，特别强调了广度优先搜索（BFS）和深度优先搜索（DFS）这两种策略的比较和优化。 迷宫问题的解决方案通常基于图遍历算法，其中广度优先搜索和深度优先搜索是两种常用的...
C语言迷宫求解算法设计
最新发布
07-07
在IT领域，迷宫求解算法是计算机科学中一个...总之，C语言迷宫求解算法设计涉及了算法设计、数据结构、搜索策略等多个IT核心概念。通过理解和实现这些算法，不仅可以提升编程技能，也能加深对计算机科学基础的理解。
利用广度优先和深度优先算法解决迷宫问题【算法设计与分析】＜图搜索问题＞
不是一切星星 都仅指示黑暗
01-18 4144
实验问题： 给定一个n*n的迷宫，要求利用广度优先和深度优先算法解决迷宫问题 问题分析： 对于此问题首先要明确搜索顺序 可以分为两种方法求解问题：1.广度优先算法2.深度优先算法 （1）对于深度优先算法来说：<如果规定遍历顺序为下，右，上，左> 首先对于起始节点寻找其下节点，如果此节点能走，将其压入堆栈，并以此节点为准，在寻找其下节点，如果能走压入，不能走，就依次寻找右，上，左节点。直到找到最后一个节点即出口，将堆栈的值依次输出就是迷宫的路径。 （2）对于广度优先算法来说：<
广度优先搜索迷宫算法的简单实现
05-27
用二维数组存储迷宫（只存在一条路径），用广度优先搜索算法计算路径
c语言bfs记录迷宫中的位置,BFS-迷宫问题-用宽度(广度)优先搜索解决最优路径问题...
weixin_39885166的博客
05-26 334
题目：给定一个大小为 N×M 的迷宫。迷宫由通道和墙壁组成，每一步可以向邻接的上下左右四格的通道移动。请求出从起点到终点所需的最小步数。请注意，本题假定从起点一定可以移动到终点。限制条件;N, M ≤ 100测试样例：N=10, M=10(迷宫如下图所示。 '#'， '.'， 'S'， 'G'分别表示墙壁、通道、起点和终点)#S######.#......#..#.#.##.##.#.#........
回溯——迷宫问题
不积极分子
03-22 168
问题描述：用一个N 阶矩阵来表示一个迷宫，该矩阵包含元素 0 1 -2 -3分别表示通道、墙、入口、出口。从入口处开始沿着通道行经，判断是否恩能够到达出口。 思路分析：问题的关键包括以下几个部分 建立迷宫包括墙、通道、入口、出口 点的移动 走过的路径如何处理 当前路径不可行后如何回溯 终止条件 如何建立迷宫 用二维数组建立一个N阶矩阵，数组中的成员为结构体Point（表示点），每个点包含坐标（...
迷宫问题
my_Love_snow的博客
07-19 626
迷宫是指一个m*n的方格，有些方格可以通过，有些方格为障碍而不能通过，假定有一只老鼠，指定其起始位置和目标位置，老鼠能自动寻找从起始位置到达目标位置的路径。老鼠的行进方向可以是4个或8个。迷宫问题的一个实例如下图所示。编程完成如下任务。 要求：  可任意指定迷宫的大小，随机产生可通和障碍方格； ② 可任意指定起始位置和目标位置； ③ 具有编辑迷宫功能，可修改当前迷宫的可通和障碍方格； ④ ...
求解迷宫游戏
放纵小开爱的博客
06-20 190
问题描述 迷宫问题求解2 • 使用深度优先的方法解决迷宫问题 • 规定迷宫的最外围为一圈墙，给出起点和终点要求输出一条正确的路径，但不要求为最短路径 • 使用opencv实现可视化，演示一个动态求解迷宫的过程 代码部分 Position.java 文件 package MazeGame; //位置类，用语记录当前所走的位置 public class Position { int x; int y; public Position(int x, int y) {
算法:迷宫求解(栈的应用)-数据结构(8)
健景的博客
05-17 730
一、问题描述 参见书上的P50-P2，给定一个迷宫，入口点和出口点，求出迷宫的路径。对于这类问题，没有什么好的办法节省效率，还是要老老实实的将所有路径都走了才能找到终点，其实这种思想我感觉就是完全二叉树，每一层都是对当前点的选择与放弃，最后结束搜索这颗树的结果是找到终点。这里用到的是栈来保存过来的路径，在堵路的时候原路返回。 二、数据结构和算法 1、栈（略） 参照我以前的博客数据结构（5）
深度与广度优先搜索迷宫问题c语言,迷宫问题的求解方式：应用深度优先和广度优先的搜索...
weixin_29570673的博客
05-25 692
用堆栈实现迷宫问题，二维数组表示迷宫：1表示墙壁，0表示可以走的路，只能横着走或竖着走不能斜着走，要求编程实现找到从左上角到右下角的路线//深度优先：有解就退出搜索(不一定是最优解)#include#includeusingnamespacestd;#defineROW5#defineCOL5typedefstructpoint{int_row;int_col;}Point;P...
深度与广度优先搜索迷宫问题c语言,深度与广度优先搜索：迷宫问题.pdf
weixin_34157892的博客
05-25 536
《数据结构课程设计 》报告题目：深度与广度优先搜索--迷宫问题专 业 计算机科学与技术学生姓名 李柏班 级 B 计算机 115学 号 1110704512指导教师 ...
c语言bfs算法走迷宫,使用广度优先算法(BFS)走迷宫
weixin_42470300的博客
05-23 856
前面介绍广度优先算法的时候提及了多次走迷宫，我们就真正的走一次迷宫试试！要求如下：输入给出迷宫矩阵的行数和列数，并给出迷宫(使用点 (.) 表示路，使用星 (*) 表示障碍物，使用S表示起点，T表示终点)例如：5 5...... * . * ..* S * ..* * * ....T *输出最短路径的长...
C语言实现迷宫问题的算法及路径绘制
- 解决迷宫问题的常见算法有深度优先搜索（DFS）、广度优先搜索（BFS）、A*搜索算法等。 - 深度优先搜索算法是通过递归或者栈来实现的，它会尝试沿着一个方向一直走下去，直到无法继续为止。 - 广度优先搜索算...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值