ACWING 844. 走迷宫 (BFS)

最新推荐文章于 2021-09-05 19:47:34 发布
最新推荐文章于 2021-09-05 19:47:34 发布
阅读量80 收藏
点赞数
分类专栏： ACWING 文章标签： 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_50859743/article/details/119743894
版权
这篇博客介绍了如何使用广度优先搜索（BFS）算法解决矩阵中最短路径的问题。通过输入一个二维矩阵，程序计算从左上角到右下角的无障碍路径的最小步数。示例给出了不同测试用例，并展示了如何实现BFS来找到答案。
摘要由CSDN通过智能技术生成

在这里插入图片描述

https://www.acwing.com/problem/content/846/

重大问题 以后tmpa a 不要搞混

#include<bits/stdc++.h>
using namespace std;

const int N=1000;

int n,m;
int _m[N][N];
bool _book[N][N];

int _path[N][N];

struct P {
    int x;
    int y;
    int s;
} que[N*N];

bool flag=false;

int _next[4][2]= {{1,0},{0,1},{-1,0},{0,-1}};

void bfs() {
    int hh=0, tt=0;
    int a, b;
    int tmpa, tmpb;

    _book[0][0]=true;

    while(hh<=tt) {
        a=que[hh].x;
        b=que[hh].y;
        for(int i=0; i<4; i++) {
            tmpa=a+_next[i][0];
            tmpb=b+_next[i][1];
            if(a<0||b<0||a>=n||b>=m) continue; //这里还是没改
            if(!_m[tmpa][tmpb]&&!_book[tmpa][tmpb]) {
                _book[tmpa][tmpb]=true;

                tt++;
                que[tt].x=tmpa;
                que[tt].y=tmpb;
                que[tt].s=que[hh].s+1;
                _path[tmpa][tmpb]=que[tt].s;
            }
            if(tmpa==n-1&&tmpb==m-1) {
                flag=true;
                break;
            }
        }
        hh++;
        if(flag) break;
    }
    cout<<que[tt].s<<endl;

//    for(int i=0;i<n;i++) {
//        for(int j=0;j<m;j++) {
//            if(_m[i][j]) cout<<"  ";
//            else cout<<_path[i][j]<<" ";
//
//        }
//        cout<<"\n";
//    }
//    cout<<"\n";

    return ;
}

int main() {

	ios::sync_with_stdio(false);
	cin.tie(0), cout.tie(0);

    cin>>n>>m;

    for(int i=0; i<n; i++)
        for(int j=0; j<m; j++)
            cin>>_m[i][j];

    bfs();

    return 0;
}

/*

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

*/

#include<bits/stdc++.h>
using namespace std;

const int N=1000;

int n,m;
int _m[N][N];
bool _book[N][N];

int _path[N][N];

struct P {
    int x;
    int y;
    int s;
} que[N*N];

bool flag=false;

int _next[4][2]= {{1,0},{0,1},{-1,0},{0,-1}};

void bfs() {

//    for(int i=0; i<25; i++) {
//        for(int j=0; j<25; j++)
//            cout<<_m[i][j]<<" ";
//        cout<<"\n";
//    }
//    cout<<"\n";

    int hh=0, tt=0;
    int a, b;
    int tmpa, tmpb;
    _book[0][0]=true;
    while(hh<=tt) {
        a=que[hh].x;
        b=que[hh].y;
        for(int i=0; i<4; i++) {
            tmpa=a+_next[i][0];
            tmpb=b+_next[i][1];
            if(tmpa<0||tmpb<0||tmpa>=n||tmpb>=m) continue;
            if(_m[tmpa][tmpb]&&!_book[tmpa][tmpb]) {
                _book[tmpa][tmpb]=true;
                tt++;
                que[tt].x=tmpa;
                que[tt].y=tmpb;
                que[tt].s=que[hh].s+1;
                _path[tmpa][tmpb]=que[tt].s;

                if(tmpa==n-1&&tmpb==m-1) {
                    flag=true;
                    break;
                }
            }
        }
        if(flag) break;

        hh++;
    }

//    printf("tt = %d\n",tt);
    cout<<que[tt].s<<endl;

//    for(int i=0;i<=tt;i++) printf("que[%d]: %d %d s = %d\n",i,que[i].x,que[i].y,que[i].s);
//
//    for(int i=0; i<n; i++) {
//        for(int j=0; j<m; j++)
//            if(!_m[i][j]) cout<<"  ";
//            else cout<<_path[i][j]<<" ";
//        cout<<"\n";
//    }
//    cout<<"\n";

    return ;
}

int main() {

	ios::sync_with_stdio(false);
	cin.tie(0), cout.tie(0);

    cin>>n>>m;

    int t;
    for(int i=0; i<n; i++)
        for(int j=0; j<m; j++) {
            cin>>t;
            if(!t) _m[i][j]=1;
        }

    bfs();

    return 0;
}

/*

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

20 20
0 0 0 0 1 0 0 1 0 0 0 1 1 0 1 1 0 0 0 0
0 1 1 0 1 0 0 1 0 1 0 0 0 0 1 1 0 1 1 1
1 0 1 0 1 1 0 0 0 0 1 0 0 1 0 0 1 1 0 0
0 0 0 0 1 0 0 0 1 0 0 0 0 0 1 0 0 0 0 0
0 1 0 1 0 0 0 1 0 0 0 1 0 0 1 0 0 0 1 1
1 0 0 0 0 1 0 0 0 0 0 1 0 1 0 0 0 1 0 0
1 0 1 1 0 1 0 0 1 1 1 0 1 0 0 1 0 1 0 0
0 0 0 0 0 1 1 0 0 0 1 1 0 1 1 0 0 0 0 0
0 0 0 0 1 1 0 0 0 0 0 0 1 0 0 0 1 0 1 0
0 0 1 0 0 0 1 0 0 0 0 1 0 1 0 1 1 1 1 0
1 1 0 0 1 0 0 0 0 0 0 0 0 1 0 0 0 0 1 1
1 0 0 0 0 1 0 0 0 1 1 0 0 1 0 0 0 0 1 0
0 0 1 1 0 0 1 0 0 0 0 0 0 1 0 0 1 1 0 0
1 1 1 0 1 0 0 0 0 0 0 1 0 0 1 1 1 0 0 0
0 0 0 0 0 1 0 1 0 0 1 0 0 0 0 0 0 1 1 0
1 0 0 1 1 0 1 1 0 0 0 1 0 1 0 0 1 0 0 0
1 1 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 1 0 1
0 1 0 0 0 1 0 0 1 0 0 0 0 0 0 1 1 1 0 1
0 1 0 1 1 1 1 0 1 0 0 0 1 0 0 1 0 0 0 1
1 0 0 0 0 0 1 0 0 0 0 1 1 0 0 0 0 1 0 0

*/
3000bookworm
关注
专栏目录
学习笔记-BFS.走迷宫和八数码
08-29
学习笔记-BFS.走迷宫和八数码
BFS.cpp.zip_bfs
09-24
在给定的标题"BFS.cpp.zip_bfs"中，我们可以推断这是一个关于使用C++实现广度优先搜索的代码示例。在描述中提到“BFS algorithm on graphs”，这表明我们要讨论的是BFS在图结构中的应用。 **BFS的基本概念：** 1. *...
src=http___i0.hdslb.com_bfs_ar
01-14
src=http___i0.hdslb.com_bfs_ar
bfs.rar_bFS maze
09-23
【标题】：“bfs.rar_bFS maze”是一个与广度优先搜索（BFS）算法相关的项目，用于解决迷宫类游戏中的路径寻找问题。 【描述】：在这个项目中，我们利用广度优先搜索策略来解决从迷宫的一个点找到另一个点的最短...
BFS.rar_bfs
09-23
标题中的"BFS.rar_bfs"指的是使用BFS（Breadth-First Search，宽度优先搜索）算法的一个程序或项目，这个项目的压缩包被命名为"BFS.rar"，可能包含了实现BFS算法的源代码、报告文档以及编译后的可执行文件。...
ACWING 786. 第k个数 (入门) (快排)
3000bookworm
07-18 1618
https://www.acwing.com/problem/content/788/ #include<iostream> using namespace std; void quickSort(int q[], int l, int r) { if(l>=r) return ; int i=l-1, j=r+1, mid=q[(l+r) >> 1]; while(i<j) { do i++; while(q[i].
ACWING 795. 前缀和 (入门) (前缀和与差分)
3000bookworm
07-18 708
https://www.acwing.com/problem/content/797/ #include<iostream> using namespace std; int main() { int n; cin>>n; int q; cin>>q; int a[n+1]; int s[n+1]; s[0]=0; for(int i=1;i<=n;i++) { cin&.
ACWING 848. 有向图的拓扑序列（拓扑排序）
3000bookworm
08-29 661
给定一个 n 个点 m 条边的有向图，点的编号是 1 到 n，图中可能存在重边和自环。 请输出任意一个该有向图的拓扑序列，如果拓扑序列不存在，则输出 −1。 若一个由图中所有点构成的序列 A 满足：对于图中的每条边 (x,y)，x 在 A 中都出现在 y 之前，则称 A 是该图的一个拓扑序列。 输入格式 第一行包含两个整数 n 和 m。 接下来 m 行，每行包含两个整数 x 和 y，表示存在一条从点 x 到点 y 的有向边 (x,y)。 输出格式 共一行，如果存在拓扑序列，则输出任意一个合法的拓扑序列即可。
ACWING 799. 最长连续不重复子序列 (入门) (双指针算法)
3000bookworm
07-20 629
https://www.acwing.com/problem/content/801/ #include<bits/stdc++.h> using namespace std; int book[100010]; int main() { int n; cin>>n; int a[n]; for(int i=0;i<n;i++) cin>>a[i]; int ans=0; for(int i=0, j.
ACWING 836. 合并集合 (并查集)
3000bookworm
08-05 598
一共有 n 个数，编号是 1∼n，最开始每个数各自在一个集合中。 现在要进行 m 个操作，操作共有两种： M a b，将编号为 a 和 b 的两个数所在的集合合并，如果两个数已经在同一个集合中，则忽略这个操作； Q a b，询问编号为 a 和 b 的两个数是否在同一个集合中； 输入格式 第一行输入整数 n 和 m。 接下来 m 行，每行包含一个操作指令，指令为 M a b 或 Q a b 中的一种。 输出格式 对于每个询问指令 Q a b，都要输出一个结果，如果 a 和 b 在同一集合内，则输出 Yes，否
ACWING 829. 模拟队列 (队列)
3000bookworm
07-26 552
实现一个队列，队列初始为空，支持四种操作： push x – 向队尾插入一个数 x； pop – 从队头弹出一个数； empty – 判断队列是否为空； query – 查询队头元素。 现在要对队列进行 M 个操作，其中的每个操作 3 和操作 4 都要输出相应的结果。 输入格式 第一行包含整数 M，表示操作次数。 接下来 M 行，每行包含一个操作命令，操作命令为 push x，pop，empty，query 中的一种。 输出格式 对于每个 empty 和 query 操作都要输出一个查询结果，每个结果占一行
ACWING 789. 数的范围 (入门) (二分)
3000bookworm
07-18 503
https://www.acwing.com/problem/content/791/ #include<bits/stdc++.h> using namespace std; int main() { int n; int k; int t; cin>>n>>k; int a[n]; for(int i=0;i<n;i++) cin>>a[i]; for(int i=0;i<k;i+.
ACWING 796. 子矩阵的和 (入门) (前缀和与差分)
3000bookworm
07-18 438
https://www.acwing.com/problem/content/798/ #include<bits/stdc++.h> using namespace std; int main() { int n,m; cin>>n>>m; int q; cin>>q; int a[n+1][m+1]; int s[n+1][m+1]; memset(s,0,sizeof(s)); .
ACWING 842. 排列数字 (DFS)
3000bookworm
08-11 402
给定一个整数 n，将数字 1∼n 排成一排，将会有很多种排列方法。 现在，请你按照字典序将所有的排列方法输出。 输入格式 共一行，包含一个整数 n。 输出格式 按字典序输出所有排列方案，每个方案占一行。 数据范围 1≤n≤7 输入样例： 3 输出样例： 1 2 3 1 3 2 2 1 3 2 3 1 3 1 2 3 2 1 https://www.acwing.com/problem/content/844/ #include<iostream> #include<cstdio>
ACWING 861. 二分图的最大匹配（匈牙利算法）（ntr算法）
3000bookworm
09-05 368
给定一个二分图，其中左半部包含 n1 个点（编号 1∼n1），右半部包含 n2 个点（编号 1∼n2），二分图共包含 m 条边。 数据保证任意一条边的两个端点都不可能在同一部分中。 请你求出二分图的最大匹配数。 二分图的匹配：给定一个二分图 G，在 G 的一个子图 M 中，M 的边集 {E} 中的任意两条边都不依附于同一个顶点，则称 M 是一个匹配。 二分图的最大匹配：所有匹配中包含边数最多的一组匹配被称为二分图的最大匹配，其边数即为最大匹配数。 输入格式 第一行包含三个整数 n1、 n2 和 m。 接下来
ACWING 840. 模拟散列表 (哈希)
3000bookworm
08-09 350
维护一个集合，支持如下几种操作： I x，插入一个数 x； Q x，询问数 x 是否在集合中出现过； 现在要进行 N 次操作，对于每个询问操作输出对应的结果。 输入格式 第一行包含整数 N，表示操作数量。 接下来 N 行，每行包含一个操作指令，操作指令为 I x，Q x 中的一种。 输出格式 对于每个询问指令 Q x，输出一个询问结果，如果 x 在集合中出现过，则输出 Yes，否则输出 No。 每个结果占一行。 数据范围 1≤N≤105 −109≤x≤109 输入样例： 5 I 1 I 2 I 3 Q 2
ACWING 828. 模拟栈 (栈)
3000bookworm
07-26 251
实现一个栈，栈初始为空，支持四种操作： push x – 向栈顶插入一个数 x； pop – 从栈顶弹出一个数； empty – 判断栈是否为空； query – 查询栈顶元素。 现在要对栈进行 M 个操作，其中的每个操作 3 和操作 4 都要输出相应的结果。 输入格式 第一行包含整数 M，表示操作次数。 接下来 M 行，每行包含一个操作命令，操作命令为 push x，pop，empty，query 中的一种。 输出格式 对于每个 empty 和 query 操作都要输出一个查询结果，每个结果占一行。 其中
ACWING 858. Prim算法求最小生成树 （最小生成树）
3000bookworm
09-04 212
给定一个 n 个点 m 条边的无向图，图中可能存在重边和自环，边权可能为负数。 求最小生成树的树边权重之和，如果最小生成树不存在则输出 impossible。 给定一张边带权的无向图 G=(V,E)，其中 V 表示图中点的集合，E 表示图中边的集合，n=|V|，m=|E|。 由 V 中的全部 n 个顶点和 E 中 n−1 条边构成的无向连通子图被称为 G 的一棵生成树，其中边的权值之和最小的生成树被称为无向图 G 的最小生成树。 输入格式 第一行包含两个整数 n 和 m。 接下来 m 行，每行包含三个整数
ACWING 847. 图中点的层次 （树与图的广度优先遍历）
3000bookworm
08-27 157
给定一个 n 个点 m 条边的有向图，图中可能存在重边和自环。 所有边的长度都是 1，点的编号为 1∼n。 请你求出 1 号点到 n 号点的最短距离，如果从 1 号点无法走到 n 号点，输出 −1。 输入格式 第一行包含两个整数 n 和 m。 接下来 m 行，每行包含两个整数 a 和 b，表示存在一条从 a 走到 b 的长度为 1 的边。 输出格式 输出一个整数，表示 1 号点到 n 号点的最短距离。 数据范围 1≤n,m≤105 输入样例： 4 5 1 2 2 3 3 4 1 3 1 4 输出样例： 1
bfs迷宫问题acwing打印路径
最新发布
04-08
BFS（广度优先搜索）是一种常用的图搜索算法，可以用于解决迷宫问题。在迷宫问题中，我们需要找到从起点到终点的最短路径。 ACwing是一个在线编程平台，提供了各种算法题目和解答。其中，ACwing上的迷宫问题是指...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值