BFS迷宫问题

  1 #include<graphics.h>
  2 #include<stdlib.h>
  3 #include<conio.h>
  4 #include<time.h>
  5 #include<vector>
  6 #include<queue>
  7 #include<stack>
  8 #include<iostream>
  9 #include <algorithm>
 10
 11 using namespace std;
 12
 13 struct point{
 14     //横坐标纵坐标
 15     int x;
 16     int y;
 17 };
 18 int **Maze;     //初始化迷宫
 19 point **Pre;    //保存任意点在路径中的前一步
 20 point move[8]={{-1,-1},{-1,0},{-1,1},{0,-1},{0,1},{1,-1},{1,0},{1,1}}; //移动方向,横竖斜都可以,八个方向
 21 char s1[]="YES";
 22 char s2[]="NO";
 23
 24 void create_line(int row ,int  column)//划线
 25 {
 26   int x, y;  // 画格子
 27    for (x=0; x<=10*(row+2); x+=10)
 28         for (y=0; y<=10*(column+2); y+=10)
 29         {
 30             line(x, 0, x, 10*(column+2));
 31             line(0, y,10*(row+2), y);
 32         }
 33 }
 34
 35
 36 void CreateTable(int row,int column)//初始化创建迷宫障碍区
 37 {
 38     int i,j;
 39     srand((unsigned int)time(NULL));
 40     for(i=0; i<row+2; i++)//创建迷宫,注意到用0表示可走,1表示墙,将整个输入的迷宫再用墙围着,处理的时候就不用特别注意边界问题
 41     {
 42         Maze[i][0] = Maze[i][column+1] = 1;
 43     }
 44     for(j=0; j<column+2; j++)
 45     {
 46         Maze[0][j] = Maze[row+1][j] = 1;
 47     }
 48
 49     for(i=1;i<=row;i++)
 50      for(j=1;j<=column;j++)
 51         {
 52              Maze[i][j]=rand()%2;
 53         }
 54
 55    for(i=1;i<=row;i++)
 56      for(j=1;j<=column;j++)
 57         {
 58              if(Maze[i][j]==1)
 59             Maze[i][j]=rand()%2;
 60         }
 61
 62     for(i=0;i<=row+1;i++)
 63      for(j=0;j<=column+1;j++)
 64      {
 65          if(Maze[i][j]==1)
 66         {
 67          setfillcolor(WHITE);
 68          fillrectangle(10*j,(10+10*i),(10+10*j),10*i);
 69         }
 70      }
 71 }
 72
 73 bool MazePath(int row,int column,int x,int y){
 74     //判断是否有路径从入口到出口,保存该路径(队列)
 75     if(x == row && y == column)return true;
 76     queue<point> q;     //用于广度优先搜索
 77     point now;          //当前位置
 78     now.x = x;
 79     now.y = y;
 80     q.push(now);
 81     Maze[now.x][now.y] = -1;
 82     while(!q.empty()){
 83         now = q.front();
 84         q.pop();
 85         for(int i=0; i<8; i++){
 86             if(now.x + move[i].x == row && now.y + move[i].y == column){
 87                 Maze[now.x + move[i].x][now.y + move[i].y] = -1;
 88                 Pre[row][column] = now;
 89                 return true;
 90             }
 91             if(Maze[now.x + move[i].x][now.y + move[i].y] == 0){
 92                 point temp;     //下个位置
 93                 temp.x = now.x + move[i].x;
 94                 temp.y = now.y + move[i].y;
 95                 q.push(temp);
 96                 Maze[temp.x][temp.y] = -1;
 97                 Pre[temp.x][temp.y] = now;
 98
 99             }
100         }
101     }
102     return false;
103 }
104
105
106 void PrintPath(int row,int column){
107     //输出最短路径
108     point temp;         //保存位置
109     stack<point> s;     //保存路径序列
110     temp.x = row;
111     temp.y = column;
112     while(temp.x != 1 || temp.y != 1){
113         s.push(temp);
114         temp = Pre[temp.x][temp.y];
115     }
116        setfillcolor(YELLOW);
117        fillrectangle(10*1,(10+10*1),(10+10*1),10*1);
118     while(!s.empty()){
119         temp = s.top();
120         setfillcolor(YELLOW);
121         fillrectangle(10*temp.y,(10+10*temp.x),(10+10*temp.y),10*temp.x);
122         s.pop();
123     }
124     cout<<endl;
125 }
126
127 void result(int row,int column)
128 {
129   if(MazePath(row,column,1,1))
130   {
131             //outtextxy(320,320,s1);
132             PrintPath(row,column);
133   }
134         else outtextxy(320,320,s2);
135 }
136
137 void Init(int row,int column)
138 {
139  Maze = new int*[row + 2];
140  Pre = new point*[row + 2];
141  for(int i=0; i<row+2; i++)
142  {
143  Maze[i] = new int[column + 2];
144  Pre[i] = new point[column + 2];
145  }
146 }
147
148 void main()
149 {
150 int row,column;
151 cin>>row>>column;
152 Init(row,column);
153 initgraph(640,640);
154 BeginBatchDraw();
155 setlinecolor(GREEN);//设置字体颜色
156 create_line(column,row);
157 CreateTable(row,column);
158 result(row,column);
159 FlushBatchDraw();
160 EndBatchDraw();
161 getch();
162 closegraph();
163 }

时间: 2024-08-13 20:52:11

BFS迷宫问题的相关文章

uva 816 BFS迷宫

这是一道比较复杂的BFS迷宫问题,状态由普通的迷宫问题的坐标(x,y)变为三个变量的状态(r,c,dir)其中dir是到达(r,c)两点的方向,这个变量非常重要,导致了这题比普通的BFS迷宫问题要更加复杂. 普通BFS解法 http://blog.csdn.net/iboxty/article/details/45888923 BFS是用队列实现的,很重要并且要理解的是:每一个节点只访问一次,而且每次BFS过程都保证压入队列中的节点到起点的距离是最短的,这题也有这样的思想. #include <

uva 816 - Abbott&#39;s Revenge(有一点难度的bfs迷宫题目)

就是典型的bfs,但这道题目的难点在于其条件的读取和判断并不简单,需要想办法来读取条件,也需要想办法来判断在每个点处能不能满足向下继续走的条件. #include<cstdio> #include<cstring> #include<string> #include<queue> #include<iostream> #include<algorithm> using namespace std; struct note { int

bfs迷宫

链接:https://ac.nowcoder.com/acm/contest/338/BSleeping is a favorite of little bearBaby, because the wetness of Changsha in winter is too uncomfortable. One morning, little bearBaby accidentally overslept. The result of being late is very serious. You

3299: [USACO2011 Open]Corn Maze玉米迷宫

3299: [USACO2011 Open]Corn Maze玉米迷宫 Time Limit: 10 Sec  Memory Limit: 128 MBSubmit: 137  Solved: 59[Submit][Status][Discuss] Description 今年秋天,约翰带着奶牛们去玩玉米迷宫.迷宫可分成NxM个格子,有些格子种了玉 米,种宥玉米的格子无法通行. 迷宫的四条边界上都是种了玉米的格子,其屮只有一个格子 没种,那就是出口. 在这个迷宫里,有一些神奇的传送点6每个传送点

(BFS)poj2935-Basic Wall Maze

题目地址 题目与最基本的BFS迷宫的区别就是有一些障碍,可以通过建立三维数组,标记某个地方有障碍不能走.另一个点是输出路径,对此建立结构体时要建立一个pre变量,指向前一个的下标.这样回溯(方法十分经典)就可以顺利的输出. 这道题难度的确很小,可是我却花了近两个小时才顺利AC,实在是现在水平太不足了,要努力学习的真的是有好多啊.不管怎样,尽力吧. 1 #include<cstdio> 2 #include<cstring> 3 #include<algorithm> 4

BFS学习总结

BFS学习总结 给你一个n*m的网格迷宫,迷宫中有些格子不能走,其他的格子都能走.然后给你起点与终点,问你从起点走到终点最少需要多少步? 上面的问题就是一个典型的BFS问题,对于这类问题来说,只要你掌握了这类问题的关键思想,其实他们都是可以用类似的思路来做的. 你可以把BFS问题想象成:从一个父亲(起点状态)生儿子(后继状态),儿子又生孙子(后继状态)的过程,只要这个家族中出生了一个满意的后代(终点状态),这个家族就不生了. 但是如果这个家族中有两个完全一样的人出生(他们的辈分不一定相同),那么

ACM/ICPC 之 BFS-简单障碍迷宫问题(POJ2935)

题目确实简单,思路很容易出来,难点在于障碍的记录,是BFS迷宫问题中很经典的题目了. POJ2935-Basic Wall Maze 题意:6*6棋盘,有三堵墙,求从给定初始点到给定终点的最短路,输出同一路长的最短路中的任一路径. 题解:BFS就不说了,对于障碍的记录,我的想法是针对每一个点都记录一次各方向上的情况.比如东边有障碍则在障碍两侧的点增加一个方向数组,用以记录左点的东侧和右点的西侧有障碍,在BFS扩展该方向时,增加一层循环判断一次该方向是否有障碍就行,时间度不会耗费很高,最坏时间度也

BFS 基础

做一道题复习一下BFS迷宫= http://hncu.acmclub.com/index.php?app=problem_title&id=111&problem_id=1102 题目描述 小明置身于一个迷宫,请你帮小明找出从起点到终点的最短路程. 小明只能向上下左右四个方向移动. 输入格式 输入包含多组测试数据.输入的第一行是一个整数T,表示有T组测试数据. 每组输入的第一行是两个整数N和M(1<=N,M<=100). 接下来N行,每行输入M个字符,每个字符表示迷宫中的一个小

迷宫问题求解——C++

迷宫问题思路 根据昨天的博客,有如下几种解决方案 克鲁斯卡尔 ,为避免死循环,需要设定优化路径的次数. Prim,为避免死循环,需要设定优化路径的次数,暂定200次. BFS , 实现简单,无死循环. DFS , 实现简单,无死循环,复杂度较低. 动态规划,实时根据权重调整方向,目前看来最合适的解决方案.需要以数据证明. 综上,本次优先选择BFS,首先不存在死循环的风险,其次算法复杂度较低,容易理解且实现.适合初步练手. 一. 思路及程序算法 首先建立迷宫,将其看作点位矩阵,先把墙堆起来,剩下的