广度优先搜索--迷宫问题（poj 3984）

最新推荐文章于 2022-08-20 15:54:17 发布
最新推荐文章于 2022-08-20 15:54:17 发布
阅读量471 收藏 2
点赞数
分类专栏： 算法 文章标签： ACM poj3984 迷宫问题 深度优先搜索 广度优先搜索
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Randyhe_/article/details/78636884
版权
Language:
迷宫问题
Time Limit: 1000MS Memory Limit: 65536K
Total Submissions: 25950 Accepted: 15104

Description

定义一个二维数组：  
int maze[5][5] = {

	0, 1, 0, 0, 0,

	0, 1, 0, 1, 0,

	0, 0, 0, 0, 0,

	0, 1, 1, 1, 0,

	0, 0, 0, 1, 0,

};

它表示一个迷宫，其中的1表示墙壁，0表示可以走的路，只能横着走或竖着走，不能斜着走，要求编程序找出从左上角到右下角的最短路线。

Input

一个5 × 5的二维数组，表示一个迷宫。数据保证有唯一解。

Output

左上角到右下角的最短路径，格式如样例所示。

Sample Input

0 1 0 0 0
0 1 0 1 0
0 0 0 0 0
0 1 1 1 0
0 0 0 1 0

Sample Output

(0, 0)
(1, 0)
(2, 0)
(2, 1)
(2, 2)
(2, 3)
(2, 4)
(3, 4)
(4, 4)

Source


#include <iostream>
#include <queue>
#include <stack>
#define NUM 7
using namespace std;
bool maze[NUM][NUM];
bool visted[NUM][NUM];//表示标记；
int as[4][2] = {{0,1},{-1,0},{0,-1},{1,0}};//东南西北

struct INFO
{
    int x;
    int y;
    INFO(){};
    INFO(int xx,int yy):x(xx),y(yy){};
};

INFO pre[NUM][NUM];

void BFS()
{
    queue<INFO> q;
    q.push(INFO(1,1));
    visted[1][1] = true;
    while(!q.empty()){
        INFO now = q.front();
        q.pop();


        for(int i = 0;i<4;i++){
            int x  = now.x+as[i][0];
            int y = now.y+as[i][1];


            if(x==5&&y==5){
                visted[x][y] = true;
                pre[x][y] = now;
                return ;
            }
            if(!maze[x][y]&&!visted[x][y]){
                visted[x][y] = true;
                q.push(INFO(x,y));
                pre[x][y] = now;
            }
        }

    }
}



void PrintPath(){
        //输出最短路径
    INFO temp;         //保存位置
    stack<INFO> s;     //保存路径序列
    temp.x = 5;
    temp.y = 5;
    while(temp.x != 1 || temp.y != 1){
        s.push(temp);
        temp = pre[temp.x][temp.y];
    }
    cout<<"(0, 0)"<<endl;
    while(!s.empty()){
        temp = s.top();
        cout<<"("<<temp.x-1<<", "<<temp.y-1<<")"<<endl;
        s.pop();
    }
}




int main()
{

    for(int i = 0;i<NUM;i++)
        maze[i][0] = maze[i][NUM-1] = maze[0][i] = maze[NUM-1][i] = true;
    for(int i = 1;i<NUM-1;i++)
        for(int j = 1;j<NUM-1;j++)
            cin>>maze[i][j];



    BFS();
    PrintPath();

//    for(int i = 1;i<NUM-1;i++){
//        for(int j = 1;j<NUM-1;j++)
//            cout <<pre[i][j].x<<pre[i][j].y<<" ";
//            cout<<endl;
//
//    }






    return 0;
}

    //需要注意的是，要用pre数组来存放他的父顶点，这里的数组是存放结构体的数组；

//此题也可以用深搜的方法：


#include <iostream>

using namespace std;
#define NUM 7
bool maze[NUM][NUM];
bool visted[NUM][NUM];//表示标记；
int as[4][2] = {{0,1},{-1,0},{0,-1},{1,0}};//东南西北
int result[NUM][NUM];
int min_leng = 1<<10;
int l;


//(0, 0)
//(1, 0)
//(2, 0)
//(2, 1)
//(2, 2)
//(2, 3)
//(2, 4)
//(3, 4)
//(4, 4)



void DFS(int x,int y)
{
    if(x==5&&y==5)
        {
        if(min_leng>l){
            min_leng = l;
            for(int i = 1;i<NUM-1;i++){
                for(int j= 1;j<NUM-1;j++){
                    if(result[i][j]==-1)
                    cout<<"("<<i-1<<", "<<j-1<<")"<<endl;
                }
            }
        }
        return ;
        }

    for(int i = 0;i<4;i++){
        int a  = x+as[i][0];
        int b = y+as[i][1];

        if(!visted[a][b]&&!maze[a][b]){
            visted[a][b] = true;
            result[a][b] = -1;
            l++;
            DFS(a, b);
            l--;
            result[a][b] = 0;
            visted[a][b] = false;

        }
    }
   
    
}


int main()
{

    for(int i = 0;i<NUM;i++)
        maze[i][0] = maze[i][NUM-1] = maze[0][i] = maze[NUM-1][i] = true;
    for(int i = 1;i<NUM-1;i++)
        for(int j = 1;j<NUM-1;j++)
            cin>>maze[i][j];

    visted[1][1]= true;
    result[1][1] = -1;
    DFS(1, 1);
    return 0;
}



赠送一个可以是任意行和8方向的：


 迷宫问题（八方向）
 input:
 1
 6 8
 0 1 1 1 0 1 1 1
 1 0 1 0 1 0 1 0
 0 1 0 0 1 1 1 1
 0 1 1 1 0 0 1 1
 1 0 0 1 1 0 0 0
 0 1 1 0 0 1 1 0
 output:
 YES
 (1,1) (2,2) (3,3) (3,4) (4,5) (4,6) (5,7) (6,8)
 */





/*

#include<iostream>
#include<queue>
#include<stack>
using namespace std;

struct point{
        //横坐标纵坐标
    int x;
    int y;
    point(){};
    point(int xx,int yy):x(xx),y(yy){};
};

int row;        //迷宫行数
int column;     //迷宫列数
bool Maze[100][100];     //初始化迷宫
int move_[8][2] ={{-1,-1},{-1,0},{-1,1},{0,-1},{0,1},{1,-1},{1,0},{1,1}};      //移动方向，横竖斜都可以，八个方向
point Pre[100][100];    //保存任意点在路径中的前一步




bool MazePath(){


        //判断是否有路径从入口到出口，保存该路径（队列）
    queue<point> q;     //用于广度优先搜索
    q.push(point(1,1));
    Maze[1][1] = -1;
    while(!q.empty()){
        point now = q.front();
        q.pop();



        for(int i=0; i<8; i++){
            int t_x =now.x + move_[i][0];
            int t_y =now.y + move_[i][1];
            if( t_x== row && t_y == column){//结束了；
                Maze[t_x][t_y] = -1;
                Pre[row][column] = now;
                return true;
            }



            if(Maze[t_x][t_y] == 0){
                //下个位置
                q.push(point(t_x,t_y));
                Maze[t_x][t_y] = -1;
                Pre[t_x][t_y] = now;

            }
        }
    }
    return false;
}







void PrintPath(){
        //输出最短路径
    point temp;         //保存位置
    stack<point> s;     //保存路径序列
    temp.x = row;
    temp.y = column;


    while(temp.x != 1 || temp.y != 1){
        s.push(temp);
        temp = Pre[temp.x][temp.y];
    }
    cout<<"(1,1)";
    while(!s.empty()){
        temp = s.top();
        cout<<' '<<'('<<temp.x<<','<<temp.y<<')';
        s.pop();
    }
    cout<<endl;
}
int main(){
    int t;          //用例数量
    cin>>t;
    while(t--){
        cin>>row>>column;
        memset(Maze, 1, sizeof(Maze));
        memset(Pre, 0, sizeof(Pre));
        for(int i=0; i<row+2; i++)
            Maze[i][0] = Maze[i][column+1] = 1;
        for(int j=0; j<column+2; j++)
            Maze[0][j] = Maze[row+1][j] = 1;
        for(int i=1; i<=row; i++){
            for(int j=1; j<=column; j++){
                cin>>Maze[i][j];
            }
        }//输入；




        if(MazePath()){
            cout<<"YES"<<endl;

            for(int i = 0;i<10;i++){
                for(int j = 1;j<10;j++)
                    cout <<Pre[i][j].x<<Pre[i][j].y<<" ";
                cout <<endl;
            } PrintPath();
        }
        else cout<<"NO"<<endl;
    }  
    return 0;  
}




Randyhe_
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
广度优先遍历解决迷宫问题
qq_57484399的博客
10-19 2488
我们之前使用深度优先遍历的方法是 , 只派一个人去探索迷宫,记录其路线 和每个节点走过的方向 , 一条道走到黑 , 当路不通时候,回溯到上一个节点 的下一个方向 , 直到这个节点全部方向都遍历完,我们就放弃路线上的这个节点 ,接着回溯到这个节点的上一个节点的另一个方向 , 我们一定可以成功 ,因为我们就算不成功,早晚也可以回溯到起点 ,从起点的下一个方向出发 ,当把所有节点所有方向都遍历完,如果有解, 我们则可以找到出口 , 无解则输出无解 .
走迷宫——BFS（广度优先搜索）
m0_72760405的博客
01-19 570
BFS广度优先搜索走迷宫例题，代码详细注释版
【游戏编程】AI-迷宫寻路算法-深度优先搜索和广度优先搜索
Health's Box
10-05 2218
状态空间搜索，如果按专业点的说法就是将问题求解过程表现为从初始状态到目标状态寻找这个路径的过程。通俗点说，就是在解一个问题时，找到一条解题的过程可以从求解的开始到问题的结果（好象并不通俗哦）。由于求解问题的过程中分枝有很多，主要是求解过程中求解条件的不确定性，不完备性造成的，使得求解的路径很多这就构成了一个图，我们说这个图就是状态空间。问题的求解实际上就是在这个图中找到一条路径可以从开始到结果。这
走迷宫问题广度优先算法实现
热门推荐
码墨
10-21 1万+
走迷宫问题 迷宫是许多小方格构成的矩形，在每个小方格中有的是墙（用1表示），有的是路（用0表示）。走迷宫就是从一个小方格沿上、下、左、右四个方向到邻近的方格，当然不能穿墙。 问题描述 实现生成迷宫（从文本中读取数据生成），输出迷宫（图案方式），探索迷宫路径（最短路径），输出迷宫路径（图案方式)。 输入的文件内容格式为： 6 5 0 1 0 1 1 0 0 1 1 1 1 0 0 1 1 0 1 0...
走迷宫之广度优先搜索
请娶你的快递
03-26 202
#include<stdio.h> #define MAX 3 int map[MAX+2][MAX+2]; int D[4][2]={0,1,1,0,0,-1,-1,0}; int book[MAX+2][MAX+2]; void Init() { for(int i=0;i<MAX+2;i++) for(int j=0;j<MAX+2;j++){ scanf...
【算法入门】广度优先搜索—raphealguo
05-15
算法入门—广度优先搜索—raphealguo
POJ3026-Borg Maze【BFS+Prim】
07-30
在计算机科学领域，图论是解决问题的重要工具之一，而BFS（广度优先搜索）和Prim算法则是其中的两种经典算法。本篇文章将围绕北大POJ3026题目“Borg Maze”来探讨这两种算法在解决实际问题中的应用。 “Borg Maze”...
POJ2251-Dungeon Master
07-31
学习这个题目，不仅可以提升编程能力，还能深入理解和应用各种算法，如深度优先搜索（DFS）、广度优先搜索（BFS）或者动态规划等。对于想要参加编程竞赛或者提升算法能力的人来说，这是一个很好的学习资源。
POJ中级搜索全部练习【解题报告+AC代码】
08-28
总的来说，这个压缩包提供了一套完整的POJ中级搜索题目的解题资源，对于学习和掌握搜索算法，特别是深度优先搜索和广度优先搜索及其变种，具有很高的参考价值。通过对这些解题报告的学习，可以了解如何将搜索算法...
搜索入门之BFS深度优先搜索.ppt
04-18
在本主题中，我们主要关注两种搜索算法：BFS（广度优先搜索）和DFS（深度优先搜索），特别是从入门的角度来探讨它们。 首先，搜索算法的核心在于构造解答树，这个树的根节点代表初始状态，而其他节点代表通过应用一...
利用广度优先搜索解决迷宫问题
qq_53626555的博客
06-14 593
利用广度优先搜锁解决迷宫问题 题目描述 给定一个迷宫（用二维数组存放），需要从一个起点走到终点（只允许上下左右走），0代表可走，1代表障碍物不可走，请找出从起点走到终点的最短路径。 样例解释 第一行输入n和m分别为二维数组（迷宫）的行和列，接着n行m列的迷宫，最后一给出两个坐标(x1,y1) (x2,y2)为起点和终点。（坐标中（x，y）为第x行第y列，而不是数学坐标系中的坐标）。 输入样例： 5 4 0 0 1 0 0 0 0 0 0 0 1 0 0 1 0 0 0 0 0 1 1 1 4 3 输出样例
广度优先搜索解决迷宫问题
buzhbuzh的博客
07-26 779
依旧是用一个二维数组来存储这个迷宫。最开始的时候小哼在迷宫的(1,1)处，它可以往右走或者往下走。深度优先是一直往右(下)走，直到走不通的时候回到这里。可以使用下面的方法： 通过”一层一层”扩展的方法来找到小哈。扩展的时候发现一个点就将这个点加入到队列中，直到走到小哈的位置(p,q)停下。 用一个结构体实现队列struct note { int x;//横坐标 int y;//
算法－BFS广度优先搜索解决迷宫问题（C++）
了解➔熟悉➔掌握➔精通
01-09 1159
分享一个大牛的人工智能教程。零基础！通俗易懂！风趣幽默！希望你也加入到人工智能的队伍中来！请点击http://www.captainbed.net /* * 问题：求解迷宫问题。 * * 分析： * 方法：BFS广度优先搜索。 * 算法： * 1、将起点入队。 * 2、队首结点可扩展的点入队；如果没有可扩展的点，将队首结点出队。 * 3、重复第2步，直到到达目标位置或者队列为空。 * 注：BFS搜索到的结果一定是最短的。BFS运用到了队列。 * * Maze_BFS.cpp - b
问题 H: 8连通迷宫（python）
weixin_45061383的博客
04-20 1003
题目描述 给定一个M*M(2≤M≤9)的迷宫，迷宫用0表示通路，1表示围墙。 迷宫的入口和出口分别位于左上角和右上角，入口和出口显然都是0。 在迷宫中移动可以沿着上、下、左、右、左上、右上、左下、右下八个方向进行，前进格子中数字为0时表示可以通过，为1时表示围墙不可通过，需要另外再找找路径。 请统计入口到出口的所有路径（不重复），并输出路径总数。若从入口无法到达出口，请输出0。 输入 第一行输入1个正整数M(≤M≤9)，表示迷宫是M行M列。 第2行到第n+1行是一个M阶的0-1方阵。 输出 统计入口到出口的
广度搜索解决迷宫问题
实践求真知
08-20 453
搜索
POJ-3984 迷宫问题 bfs+pair
A confused programmer
07-25 248
这道题在bfs求最短路的基础上，要求记录路径，观看了网上大佬的代码Orz，发现巧妙之处在于那个vis数组。 想记录下来主要是因为debug了好久QAQ... 就是for循环中p值改变的问题。。详见注释吧。。 #include<cstdio> #include<cstring> #include<iostream> #include<algorith...
用广度优先搜索解迷宫问题
xyjikl
05-05 502
//By LYLtim      #include      const int di[4] = {0,1,0,-1},             dj[4] = {1,0,-1,0};      unsigned maze[5][5] = {       2, 1, 0, 0, 0,       0, 1, 0, 1, 0,       0, 0, 0, 0, 0,     
广度优先算法--迷宫问题
HelloWorld
10-26 3771
遍历过程 与深度优先算法不同的是，广度优先算法是先遍历层级在前的元素再遍历层级在后的元素，即再遍历完第一层元素后，再依次遍历第二层元素，依次类推。 而深度优先算法是从一个节点出发依次遍历下一层节点直到节点之后没有后继元素。 经典迷宫问题 定义一个二维数组： int maze[5][5] = { 0, 1, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1...
POJ3984—迷宫问题java
最新发布
11-02
可以使用广度优先搜索或者深度优先搜索算法来解决这个问题。 下面是一个使用广度优先搜索算法的Java代码示例： ```java import java.util.*; public class Main { static int[][] maze = new int[5][5]; // 迷宫...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值