2017、2019蓝桥杯迷宫问题(DFS+BFS）（相关问题汇总）

最新推荐文章于 2023-11-23 17:42:17 发布
最新推荐文章于 2023-11-23 17:42:17 发布
阅读量723 收藏 15
点赞数 1
分类专栏： 蓝桥杯
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hy1255564202/article/details/115526259
版权

文章目录

一 蓝桥杯迷宫

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

#include<bits/stdc++.h>
#define ll long long
using namespace std;
#define N 4
#define M 6
bool vis[N][M];
char G[N][M];
char ch[]={'D','L','R','U'};
int dir[4][2]={{1,0},{0,-1},{0,1},{-1,0}};

struct Point{
int x,y;
string road;
Point(int a,int b){
x=a;
y=b;
}
};
void dfs(Point p){
int x=p.x;
int y=p.y;
if(G[x][y]=='1'){
    return;
}

if(x==N-1&&y==M-1){
    cout<<p.road<<endl;
    return;
}
for(int i=0;i<4;i++){
    int dx=x+dir[i][0];
    int dy=y+dir[i][1];
    if(dx>=0&&dx<N&&dy>=0&&dy<M&&!vis[dx][dy]){
        Point pp(dx,dy);
        pp.road=p.road+ch[i];
        vis[dx][dy]=true;
        dfs(pp);
        vis[dx][dy]=false;
    }
}



}




void BFS(){
    queue<Point> q;
    Point p(0,0);
    p.road="";
    q.push(p);
    vis[0][0]=true;

    while(!q.empty()){
        Point top=q.front();
        q.pop();
        if(top.x==N-1&&top.y==M-1){
            cout<<top.road<<endl;
            break;
        }

        for(int i=0;i<4;i++){
            int dx=top.x+dir[i][0];
            int dy=top.y+dir[i][1];
            if(dx>=0&&dx<N&&dy>=0&&dy<M&&!vis[dx][dy]&&G[dx][dy]=='0'){
                Point pp(dx,dy);
                pp.road=top.road+ch[i];
                vis[dx][dy]=true;
                q.push(pp);
            }

        }


    }


}


int main(){
for(int i=0;i<N;i++){
     for(int j=0;j<M;j++){
        cin>>G[i][j];
    }
    getchar();
}

//BFS();
Point p(0,0);
p.road="";
dfs(p);

return 0;
}

dfs打印的结果：第一排就是（因为是按下 左 右 上遍历的，所以第一排就是，bfs同理）：
在这里插入图片描述
bfs，dfs参考：
https://zhuanlan.zhihu.com/p/24986203

二 蓝桥杯另一个迷宫

在这里插入图片描述
在这里插入图片描述

#include<bits/stdc++.h>
#define ll long long
using namespace std;
char a[11][11];
bool vis[11][11];
bool flag;
int ans;
int n;
void dfs(int i,int j){
if(!(i>=1&&i<=n&&j>=1&&j<=n)){
    ans++;
    return;
}

if(a[i][j]=='U'&&!vis[i-1][j]){
    vis[i-1][j]=true;
    dfs(i-1,j);
    vis[i-1][j]=false;
}
if(a[i][j]=='D'&&!vis[i+1][j]){
    vis[i+1][j]=true;
    dfs(i+1,j);
    vis[i+1][j]=false;
}
if(a[i][j]=='L'&&!vis[i][j-1]){
    vis[i][j-1]=true;
    dfs(i,j-1);
    vis[i][j-1]=false;
}
if(a[i][j]=='R'&&!vis[i][j+1]){
    vis[i][j+1]=true;
    dfs(i,j+1);
    vis[i][j+1]=false;
}
}



int main(){

cin>>n;
getchar();
for(int i=1;i<=n;i++){
     for(int j=1;j<=n;j++)
    cin>>a[i][j];
    getchar();
}

for(int i=1;i<=n;i++)
    for(int j=1;j<=n;j++){
        dfs(i,j);
    }

cout<<ans<<endl;
return 0;
}

三 《算法笔记》里面的bfs讲解的“块”

在这里插入图片描述

#include<bits/stdc++.h>
#define ll long long
using namespace std;
int G[6][7];
bool vis[6][7];
//об ср ио вС
int dir[4][2]= {{0,1},{1,0},{0,-1},{-1,0}};
struct Node
{
    int x,y;
    Node(int xx,int yy)
    {
        x=xx;
        y=yy;
    }
};

void dfs(int x,int y){
    vis[x][y]=true;

for(int i=0;i<4;i++){
    int dx=x+dir[i][0];
    int dy=y+dir[i][1];
    if(dx>=0&&dx<=6&&dy>=0&&dy<=7&&!vis[dx][dy]&&G[dx][dy]==1){
        dfs(dx,dy);
    }


}

}




void bfs(int x,int y)
{
    queue<Node> q;
    q.push(Node(x,y));
    vis[x][y]=true;

    while(!q.empty())
    {
        Node top=q.front();
        q.pop();
        for(int i=0; i<4; i++)
            {
                int dx=top.x+dir[i][0];
                int dy=top.y+dir[i][1];
                if(dy>=0&&dy<7&&dx>=0&&dx<6&&vis[dx][dy]==false&&G[dx][dy]==1)
                {
                    q.push(Node(dx,dy));
                    vis[dx][dy]=true;
                }

            }

    }

}





int main()
{
    int ans=0;
    for(int i=0; i<6; i++)
        for(int j=0; j<7; j++)
            cin>>G[i][j];

    for(int i=0; i<6; i++)
        for(int j=0; j<7; j++)
        {
            if(G[i][j]==1&&vis[i][j]==false)
            {
                ans++;
                dfs(i,j);
            }
        }

    cout<<ans<<endl;
    return 0;
}

四 蓝桥杯的maze迷宫

maze.cpp(找到题再补上描述)

#include<bits/stdc++.h>
#define ll long long
using namespace std;
#define n 5
#define m 5
int ans;
char ch[n][m];
bool vis[n][m];
int dir[4][2]={{0,1},{1,0},{-1,0},{0,-1}};
struct Node{
int x,y;
int step;
Node(int xx,int yy,int sstep){
x=xx;
y=yy;
step=sstep;
}
};



void bfs(int x,int y){
queue<Node> q;
q.push(Node(x,y,0));
vis[x][y]=true;


while(!q.empty()){
    Node top=q.front();
    q.pop();

    if(top.x==4&&top.y==3){
        cout<<top.step<<endl;
        break;
    }

    for(int i=0;i<4;i++){
        int dx=top.x+dir[i][0];
        int dy=top.y+dir[i][1];

        if(dx>=0&&dx<n&&dy>=0&&dy<m&&ch[dx][dy]!='*'&&!vis[dx][dy]){
            q.push(Node(dx,dy,top.step+1));
            vis[dx][dy]=true;

        }

    }


}




}



int main(){
for(int i=0;i<n;i++){
    for(int j=0;j<m;j++)
        cin>>ch[i][j];
    getchar();
}
bfs(2,2);


return 0;
}

五 方格填数（蓝桥杯2016初赛）

在这里插入图片描述

#include<bits/stdc++.h>
#define ll long long
using namespace std;
int a[3][4];
bool vis[10];
int ans;
上 下 左 右  左上 左下 右上  右下
//int dir[8][2]={{-1,0},{1,0},{0,-1},{0,1},{-1,-1},{1,-1},{-1,1},{1,1}};
//上  左   左上 右上
int dir[][2]={{-1,0},{0,-1},{-1,-1},{-1,1}};


bool check(int x,int y,int num){
    for(int i=0;i<4;i++){
        int dx=x+dir[i][0];
        int dy=y+dir[i][1];
        if(dx>=0&&dx<=2&&dy>=0&&dy<=3){
            if(abs(num-a[dx][dy])==1)
            return false;
        }

    }
    return true;
}

void dfs(int a[3][4],int x,int y)
{
    if(x==2&&y==3)
    {
        ans++;
        return;
    }

    for(int num=0; num<=9; num++)
    {
        if(!vis[num])
        {
            if(check(x,y,num)){
            a[x][y]=num;
            vis[num]=true;
            if(y<3)
                dfs(a,x,y+1);
            else
                dfs(a,x+1,0);
            vis[num]=false;
            }

        }
    }

}

int main()
{
    a[0][0]=a[2][3]=-20;
    dfs(a,0,1);
    cout<<ans<<endl;


    return 0;
}

对0-9数字的dfs遍历：

#include<bits/stdc++.h>
#define ll long long
using namespace std;
int a[3][4];
int b[10];
bool vis[10];
void dfs(int d)
{
    if(d==10)
    {
        for(int i=0; i<10; i++)
            cout<<b[i];
        cout<<endl;
        return;
    }

    for(int num=0; num<=9; num++)
    {
        if(!vis[num])
        {
            b[d]=num;
            vis[num]=true;
            dfs(d+1);
            vis[num]=false;
        }
    }

}

int main()
{
    dfs(0);



    return 0;
}

六 剪邮票（蓝桥杯2016初赛）

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

//剪邮票
#include<bits/stdc++.h>
#define ll long long
using namespace std;
int a[12]={0,0,0,0,0,0,0,1,1,1,1,1};
int b[3][4];
bool vis[3][4];
int ans;
//上 下 左 右
int dir[4][2]={{-1,0},{1,0},{0,-1},{0,1}};

void dfs(int x,int y){
vis[x][y]=true;
for(int i=0;i<4;i++){
    int dx=x+dir[i][0];
    int dy=y+dir[i][1];
    if(dx>=0&&dx<=2&&dy>=0&&dy<=3&&!vis[dx][dy]&&b[dx][dy]==1){
        vis[dx][dy]=true;
        dfs(dx,dy);
    }
}
}


bool judge(){
memset(b,0,sizeof(b));
memset(vis,0,sizeof(vis));
for(int i=0;i<12;i++)
    b[i/4][i%4]=a[i];



int num=0;
for(int i=0;i<3;i++)
for(int j=0;j<4;j++){
    if(b[i][j]==1&&!vis[i][j]){
        num++;
        dfs(i,j);
    }
}
if(num==1)
    return true;
else
    return false;

}

int main(){
do{
    if(judge())
        ans++;
}while(next_permutation(a,a+12));



cout<<ans<<endl;

return 0;
}

七 [蓝桥杯2015初赛]牌型种数

（又一个dfs，有点不同）

在这里插入图片描述

#include<bits/stdc++.h>
#define ll long long
using namespace std;
int ans;
void dfs(int num,int total){
if(total==13){
    ans++;
    return;
}
if(num>13||total>13){
    return;
}

for(int i=0;i<=4;i++){
    dfs(num+1,total+i);
}

}


int main(){
dfs(1,0);
cout<<ans<<endl;



return 0;
}
hy1255564202
关注
  • 1
    点赞
  • 踩
  • 15
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++-VS2019-迷宫寻路BFS+DFS代码.zip
07-22
最终效果是实现了Prim随机生成迷宫，BFS&DFS路径显示、最短路长度显示、过程动态展示，主函数中有菜单，操作方便。 不仅可以用来读代码长知识、还可以用作算法演示。 附带第五版的exe文件，欢迎使用！
蓝桥杯（迷宫问题）
Bingbonging的博客
11-03 2002
蓝桥杯迷宫问题（dfs思想的运用）
【c++】蓝桥杯1216题：走迷宫（bfs）
m0_64552336的博客
04-02 484
给定一个 N×M 的网格迷宫 G。G 的每个格子要么是道路，要么是障碍物（道路用 1 表示，障碍物用 0 表示）。已知迷宫的入口位置为 ()，出口位置为 (​,​)。问从入口走到出口，最少要走多少个格子。
蓝桥杯——迷宫(BFS)
qq_33880925的博客
03-16 664
【代码】蓝桥杯——迷宫(BFS)
蓝桥杯——迷宫
weixin_45688536的博客
01-23 1801
题目来源：2019，省赛 知识点：BFS，C++文件读写 题目描述 本题为填空题，只需要算出结果后，在代码中使用输出语句将所填结果输出即可。 下图给出了一个迷宫的平面图，其中标记为 1 的为障碍，标记为 0 的为可以通行的地方。 010000 000100 001001 110000 迷宫的入口为左上角，出口为右下角，在迷宫中，只能从一个位置走到这个它的上、下、左、右四个方向之一。 对于上面的迷宫，从入口开始，可以按 DRRURRDDDR的顺序通过迷宫， 一共 10 步。其中 D、U、L、R 分别表
蓝桥杯算法双周赛心得——迷宫逃脱（dp）
最新发布
晴天学长
11-23 337
越界的地方不能算进去，不然不可达到的地方也会加入答案中。
DFS+BFS深度+广度优先遍历.cpp
01-17
DFS+BFS深度+广度优先遍历.cpp
列表实现岛屿数量（DFS+BFS）
12-21
标题中的“列表实现岛屿数量（DFS+BFS）”是指在一个二维网格中，通过深度优先搜索（DFS）和广度优先搜索（BFS）算法来计算由‘1’（陆地）组成的岛屿的数量。这个问题通常出现在数据结构和算法的练习中，如LeetCode...
PUZZLE15_dfs_C++求解15拼图问题_bfs_
10-02
在这个问题中，我们将探讨如何使用深度优先搜索（DFS）、广度优先搜索（BFS）以及迭代加深的深度优先搜索（IDDFS）来解决15拼图问题。 **深度优先搜索（DFS）：** DFS是一种用于遍历或搜索树或图的算法。在这个问题...
图的相关算法总结dfs+bfs+prim+kruskal等
01-09
图的相关算法比较全面的总结，包括了图的深度和广度遍历算法，prim和kruskal两种最小生成树的算法，邻接矩阵和邻接表两种储存结构，做课程设计、实验报告或者数据结构学习者可以参考参考啊``源代码都是我亲手打的，...
蓝桥杯精选赛题算法系列——迷宫——DFS
wzy的博客
03-04 6135
已收录此专栏。 今天我们会全面学习 DFS 的相关知识，包括理论、模板、真题等。 深度优先搜索（DFS, Depth-First Search）和宽度优先搜索（BFS, Breadth-First Search，或称为广度优先搜索）是基本的暴力技术，常用于解决图、树的遍历问题。 我们以老鼠走迷宫为例说明 BFS 和 DFS 的原理吧。迷宫内的路错综复杂，老鼠从入口进去后，怎么才能找到出口？有两种方案： 1.一只老鼠走迷宫。它在每个路口，都选择先走右边（当然，选择先走左边也可以），能走多远就走多远；直到碰壁无
蓝桥杯真题：迷宫（2017 年省赛）
Alex的博客
11-12 6902
题目描述 本题为填空题，只需要算出结果后，在代码中使用输出语句将所填结果输出即可。 X 星球的一处迷宫游乐场建在某个小山坡上。它是由 10 \times 1010×10 相互连通的小房间组成的。 房间的地板上写着一个很大的字母。我们假设玩家是面朝上坡的方向站立，则： L 表示走到左边的房间， R 表示走到右边的房间， U 表示走到上坡方向的房间， D 表示走到下坡方向的房间。 X 星球的居民有点懒，不愿意费力思考。他们更喜欢玩运气类的游戏。这个游戏也是如此！ 开始的时候，直升机把 100100 名玩家放
迷宫(模拟)
computer science
02-05 1220
1.问题描述：   X星球的一处迷宫游乐场建在某个小山坡上。 它是由10x10相互连通的小房间组成的。 房间的地板上写着一个很大的字母。 我们假设玩家是面朝上坡的方向站立，则： L表示走到左边的房间， R表示走到右边的房间， U表示走到上坡方向的房间， D表示走到下坡方向的房间。 X星球的居民有点懒，不愿意费力思考。 他们更喜欢玩运气类的游戏。这个游戏也是如此！ 开始的时候...
蓝桥杯2022年第十三届省赛真题-回忆迷宫
Gojavaee的博客
11-16 2655
蓝桥杯2022年第十三届省赛真题-回忆迷宫 100%过测试 个人解法
[蓝桥杯2019初赛]迷宫-DFS、BFS两种方法
lifehappy
02-02 6689
迷宫问题的最短路，加最小字典序 迷宫文件maze.txt传送门 . . . dfs的版本 #include<iostream> #include<cstring> using namespace std; const int ax[4]={0,0,1,-1}; const int ay[4]={1,-1,0,0}; const char dir[5]={'R','L','...
蓝桥杯 BFS 迷宫问题超详解（学霸的迷宫）
highlighters的博客
05-25 1753
个人思路分析 原题链接放这，不啰嗦了哈~ http://lx.lanqiao.cn/problem.page?gpid=T291 由于一开始没有接触这类问题，也对BFS不太了解，我第一反应是用常用的暴力DFS算法，一直走，撞墙就回来，直到找到终点（这就叫不撞南墙心不死） ，一开始觉得500*500的迷宫也不是很大嘛，应该没问题~~（确信）~~ ，但是发现超时了。。。 仔细思考了一下，觉得超时的原因是，实际上每走一步消耗的时间比想象中多，因为不只是计算步数，还有路径等等都需要时间。 既然DFS不行，在网上看了
蓝桥杯2019初赛]迷宫(dfs版本)
jziwjxjd的博客
01-24 2221
传送门 大意: 题目的意思还是模板的搜索，不同的是我们要记录路径了，而且是最短字典序最小的路径。 思路: 1、对于字典序最小，也就是说我们要尽量先往下走，然后是左… 这个很简单，因为在dfs中是顺序枚举，所以我们这样 b[5]={0,1,0,0,-1}//控制X坐标 c[5]={0,0,-1,1,0};//控制Y坐标 2、记录路径。开一个一维数组VV,向下走记为1，向左为2…。 3、每次到达终点时...
【蓝桥杯训练】DFS与BFS讲解
一个真ikun
03-14 1476
DFS属于图算法的一种，是针对图和树的遍历算法。深度优先搜索是图论中的经典算法，利用深度优先搜索算法可以产生目标图的相应拓扑排序表，利用拓扑排序表可以方便的解决很多相关的图论问题，如最大路径问题等等。一般用堆或栈来辅助实现DFS算法。其过程简要来说是对每一个可能的分支路径深入到不能再深入为止，如果遇到死路就往回退，回退过程中如果遇到没探索过的支路，就进入该支路继续深入，每个节点只能访问一次。
蓝桥杯专题之递归+dfs+bfs篇
qq_53133234的博客
04-01 2405
题目列表： 2014年：李白打酒，地宫取宝 2015年：牌型种数 2016年：方格填数，剪邮票 2020年：走方格，七段码 1.李白打酒
C语言求解一下蓝桥杯迷宫问题
04-01
蓝桥杯迷宫问题可以使用深度优先搜索（DFS）或广度优先搜索（BFS）来解决。下面是使用DFS的思路： 1. 定义一个二维数组表示迷宫，0表示可以通过，1表示障碍物。 2. 定义一个二维数组表示已经访问过的位置，初始值都...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值