用队列解迷宫问题
2013-12-28 11:48
232 查看
/***********************************************************************************
队列是一种先进先出的机制,用队列来解迷宫问题的思想如下:
将起点标记为已走过并入队列;
while (队列非空)
{
出队一个点p;
if (p这个点是终点)
{
break;
}
否则沿下,右,上,左四个方向探索相邻的点
if (和p相邻的点有路可走,并且还没走过)
{
将相邻的点标记为已走过并入队,它的前趋就是刚出队的p点;
}
}
if (p点是终点)
{
while (p点有前趋)
{
打印p点的坐标;
p点 = p点的前趋;
}
}
else
{
没有路线可以到达终点;
}
***************************************************************************************/
#include <stdio.h>
#define MAX_ROW 8
#define MAX_COL 8
typedef struct point
{
int row;
int col;
}Point;
Point queue[MAX_ROW * MAX_COL];
unsigned int head = 0;
unsigned int tail = 0;
unsigned int flag = 0;
int maze[MAX_ROW][MAX_COL] = {
0, 1, 0, 1, 0, 0, 1, 0,
0, 0, 1, 0, 1, 0, 0, 1,
0, 0, 0, 0, 1, 1, 1, 1,
1, 0, 1, 0, 1, 0, 0, 1,
1, 0, 1, 0, 0, 1, 1, 1,
1, 1, 1, 0, 0, 0, 0, 1,
0, 0, 0, 0, 0, 1, 1, 1,
1, 1, 1, 1, 0, 0, 0, 0,
};
Point FootPrints[MAX_ROW][MAX_COL] = {
{{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1}},
{{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1}},
{{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1}},
{{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1}},
{{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1}},
{{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1}},
{{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1}},
{{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1}},
};
void Print_Maze(void)
{
int i = 0, j = 0;
for(i = 0; i < MAX_ROW; i++)
{
for(j = 0; j < MAX_COL; j++)
{
printf("%2d", maze[i][j]);
}
printf("\n");
}
printf("*************************************\n");
}
int QueueEmpty(void)
{
return head == tail;
}
void InQueue(Point p)
{
queue[tail++] = p;
}
Point OutQueue(void)
{
if(! QueueEmpty())
{
return queue[head++];
}
}
void Print_Foot(void)
{
Point p = {MAX_ROW-1, MAX_COL-1};
while(FootPrints[p.row][p.col].row != -1)
{
printf("{%d, %d} \n", p.row, p.col);
p = FootPrints[p.row][p.col];
}
printf(" seccess out ! \n");
}
void VisitPoint(int row, int col, Point p)
{
Point tempPoint = {row, col};
maze[row][col] = 2;/*访问的点要标记为2*/
InQueue(tempPoint);/*访问的点要入队列*/
FootPrints[row][col] = p;/*当前点的坐标记录上一个点的坐标*/
}
int main(void)
{
Point p = {0, 0};/*设定出发点*/
maze[p.row][p.col] = 2;/*访问过的点标记为2*/
InQueue(p);/*访问的点要入队列*/
while(! QueueEmpty())
{
Print_Maze();/*打印迷宫图*/
p = OutQueue();/*出队列*/
if((p.row+1 == MAX_ROW) && (p.col+1 == MAX_COL))
{
printf("it's go out ! \n");
flag = 1;
break;
}
if((p.row+1 < MAX_ROW) && (maze[p.row+1][p.col] == 0))
{
VisitPoint(p.row+1, p.col, p);
}
if((p.col+1 < MAX_COL) && (maze[p.row][p.col+1] == 0))
{
VisitPoint(p.row, p.col+1, p);
}
if((p.row-1 >= 0) && (maze[p.row-1][p.col] == 0))
{
VisitPoint(p.row-1, p.col, p);
}
if((p.col-1 >= 0) && (maze[p.row][p.col-1] == 0))
{
VisitPoint(p.row, p.col-1, p);
}
}
if(flag)
{
Print_Foot();
}
else
{
printf("No Path ! \n");
}
return 0;
}
/*************************************************************************************************************************************************************
从打印的结果可以看出,这个算法的特点是沿着每个点的各个方向同时展开搜索,每个可以走通的方向轮流往前走一步,这称为广度优先搜索
(BFS,Breadth First Search)。广度优先搜索是一种步步为营的策略,每次都从各个方向探索一步,将前线推进一步,队列中的元素总是由各个
方向上可以走得通的点组成的,可见正是队列先进先出的性质使这个算法具有了广度优先的特点。广度优先搜索还有一个特点是可以找到从起点到
终点的最短路径,而深度优先搜索找到的不一定是最短路径。
**************************************************************************************************************************************************************/
队列是一种先进先出的机制,用队列来解迷宫问题的思想如下:
将起点标记为已走过并入队列;
while (队列非空)
{
出队一个点p;
if (p这个点是终点)
{
break;
}
否则沿下,右,上,左四个方向探索相邻的点
if (和p相邻的点有路可走,并且还没走过)
{
将相邻的点标记为已走过并入队,它的前趋就是刚出队的p点;
}
}
if (p点是终点)
{
while (p点有前趋)
{
打印p点的坐标;
p点 = p点的前趋;
}
}
else
{
没有路线可以到达终点;
}
***************************************************************************************/
#include <stdio.h>
#define MAX_ROW 8
#define MAX_COL 8
typedef struct point
{
int row;
int col;
}Point;
Point queue[MAX_ROW * MAX_COL];
unsigned int head = 0;
unsigned int tail = 0;
unsigned int flag = 0;
int maze[MAX_ROW][MAX_COL] = {
0, 1, 0, 1, 0, 0, 1, 0,
0, 0, 1, 0, 1, 0, 0, 1,
0, 0, 0, 0, 1, 1, 1, 1,
1, 0, 1, 0, 1, 0, 0, 1,
1, 0, 1, 0, 0, 1, 1, 1,
1, 1, 1, 0, 0, 0, 0, 1,
0, 0, 0, 0, 0, 1, 1, 1,
1, 1, 1, 1, 0, 0, 0, 0,
};
Point FootPrints[MAX_ROW][MAX_COL] = {
{{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1}},
{{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1}},
{{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1}},
{{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1}},
{{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1}},
{{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1}},
{{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1}},
{{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1}},
};
void Print_Maze(void)
{
int i = 0, j = 0;
for(i = 0; i < MAX_ROW; i++)
{
for(j = 0; j < MAX_COL; j++)
{
printf("%2d", maze[i][j]);
}
printf("\n");
}
printf("*************************************\n");
}
int QueueEmpty(void)
{
return head == tail;
}
void InQueue(Point p)
{
queue[tail++] = p;
}
Point OutQueue(void)
{
if(! QueueEmpty())
{
return queue[head++];
}
}
void Print_Foot(void)
{
Point p = {MAX_ROW-1, MAX_COL-1};
while(FootPrints[p.row][p.col].row != -1)
{
printf("{%d, %d} \n", p.row, p.col);
p = FootPrints[p.row][p.col];
}
printf(" seccess out ! \n");
}
void VisitPoint(int row, int col, Point p)
{
Point tempPoint = {row, col};
maze[row][col] = 2;/*访问的点要标记为2*/
InQueue(tempPoint);/*访问的点要入队列*/
FootPrints[row][col] = p;/*当前点的坐标记录上一个点的坐标*/
}
int main(void)
{
Point p = {0, 0};/*设定出发点*/
maze[p.row][p.col] = 2;/*访问过的点标记为2*/
InQueue(p);/*访问的点要入队列*/
while(! QueueEmpty())
{
Print_Maze();/*打印迷宫图*/
p = OutQueue();/*出队列*/
if((p.row+1 == MAX_ROW) && (p.col+1 == MAX_COL))
{
printf("it's go out ! \n");
flag = 1;
break;
}
if((p.row+1 < MAX_ROW) && (maze[p.row+1][p.col] == 0))
{
VisitPoint(p.row+1, p.col, p);
}
if((p.col+1 < MAX_COL) && (maze[p.row][p.col+1] == 0))
{
VisitPoint(p.row, p.col+1, p);
}
if((p.row-1 >= 0) && (maze[p.row-1][p.col] == 0))
{
VisitPoint(p.row-1, p.col, p);
}
if((p.col-1 >= 0) && (maze[p.row][p.col-1] == 0))
{
VisitPoint(p.row, p.col-1, p);
}
}
if(flag)
{
Print_Foot();
}
else
{
printf("No Path ! \n");
}
return 0;
}
/*************************************************************************************************************************************************************
从打印的结果可以看出,这个算法的特点是沿着每个点的各个方向同时展开搜索,每个可以走通的方向轮流往前走一步,这称为广度优先搜索
(BFS,Breadth First Search)。广度优先搜索是一种步步为营的策略,每次都从各个方向探索一步,将前线推进一步,队列中的元素总是由各个
方向上可以走得通的点组成的,可见正是队列先进先出的性质使这个算法具有了广度优先的特点。广度优先搜索还有一个特点是可以找到从起点到
终点的最短路径,而深度优先搜索找到的不一定是最短路径。
**************************************************************************************************************************************************************/
相关文章推荐
- 队列求迷宫问题
- YTU 3006: 迷宫问题(栈与队列)
- c++链表实现队列,深搜加宽搜,加模版类实现迷宫问题;
- c++广搜法解迷宫问题(队列)
- [POJ](3984)迷宫问题 ---BFS+队列模拟(图+队列模拟)***
- 解决迷宫问题, 栈和队列
- 使用栈和队列求解迷宫问题(标准库)
- 哈理工OJ1621_迷宫问题II【BFS+优先队列】
- [数据结构] 迷宫问题(栈和队列,深搜和广搜)
- 栈和队列_迷宫问题_递归
- 迷宫问题(栈,递归,队列)
- poj 3984 迷宫问题 【BFS + 优先队列 + stack路径记录】
- 迷宫问题队列实现
- 栈和队列的底层实现及迷宫问题
- C语言使用广度优先搜索算法解决迷宫问题(队列)
- 队列应用2:求解迷宫问题,最短路径
- [数据结构] 迷宫问题(栈和队列,深搜和广搜)
- poj3984(迷宫问题)(bfs和队列)
- 哈理工OJ 1621迷宫问题II(优先队列广搜)
- [数据结构] 迷宫问题(栈和队列,深搜和广搜)