bfs搜索 与搜索顺序有关

已于 2022-04-04 11:41:17 修改
阅读量502 收藏
点赞数
分类专栏： 搜索 没理解很好的题目 文章标签： 宽度优先 算法 矩阵
于 2021-12-12 10:48:51 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/cosx_/article/details/121878417
版权

迷宫

code：

#include<bits/stdc++.h>
#define endl '\n'
#define ll long long
#define ull unsigned long long
#define ld long double
#define all(x) x.begin(), x.end()
#define eps 1e-6
using namespace std;
const int maxn = 5e2 + 9;
const int mod = 1e9 + 7;
const int inf = 0x3f3f3f3f;
const ll INF = 0x3f3f3f3f3f3f3f3f;
ll n, m;
bool vis[maxn][maxn][2];
int xx[4] = {0, 0, 1, -1};
int yy[4] = {1, -1, 0, 0};
char mp[maxn][maxn];
struct node{
	int x, y, flag, step;
};
bool check(int x, int y){
	if(x < 1 || y < 1 || x > n || y > m) return 1;
	return 0;
}
queue <node> q;
int bfs()
{
	while(!q.empty())
	{
		node now = q.front();q.pop();
		if(mp[now.x][now.y] == 'E') return now.step;
		for(int i = 0; i < 4; ++i){
			int dx = now.x + xx[i], dy = now.y + yy[i], flag = now.flag;
			if(mp[dx][dy] == 'K') flag = 1;
			if(check(dx, dy) || vis[dx][dy][flag] || mp[dx][dy] == 'W' || (mp[dx][dy] == 'D' && !flag)) continue;
			vis[dx][dy][flag] = 1;
			q.push({dx, dy, flag, now.step + 1});
		}
	}
	return -1;
}
void work()
{
	cin >> n >> m;
	node st;
	st.flag = 0, st.step = 0;
	for(int i = 1; i <= n; ++i){
		cin >> (mp[i] + 1);
		for(int j = 1; j <= m; ++j) if(mp[i][j] == 'S') st.x = i, st.y = j;
	}		
	q.push(st);
	vis[st.x][st.y][0] = 1;
	cout << bfs();
}

int main()
{
	ios::sync_with_stdio(0);
//	int TT;cin>>TT;while(TT--)
	work();
	return 0;
}

小红的rpg游戏
题意：
一个 n ∗ m n*m n∗m 的迷宫，每个位置可能为 ∗ * ∗ 墙壁， . . . 空地和怪物（1-9的数字表示血量），初始血量为 h h h，消灭怪物会花费响应的血量，当血量 < = 0 <=0 <=0 则死亡，求左上角到右下角的最短路径。
思路：
这种题目搜索顺序会影响结果
最多不超过 10 10 10 个怪物，因此可以二进制枚举消灭哪些怪物，然后每次 b f s bfs bfs 维护最短路径
code：

#include<bits/stdc++.h>
#define endl '\n'
#define ll long long
#define ull unsigned long long
#define ld long double
#define all(x) x.begin(), x.end()
#define eps 1e-6
using namespace std;
const int maxn = 50 + 9;
const int mod = 1e9 + 7;
const int inf = 0x3f3f3f3f;
const ll INF = 0x3f3f3f3f3f3f3f3f;
ll n, m, h;
char mp[maxn][maxn];
bool vis[maxn][maxn], ok[maxn][maxn];
vector <pair<int,int> > v;
int dx[4] = {0, 0, 1, -1};
int dy[4] = {1, -1, 0, 0};
struct node{
	int x, y, step;
};
int ans = inf;

bool check(int x, int y){
	if(x < 1 || y < 1 || x > n || y > m) return 0;
	return 1;
}
void bfs()
{
	queue<node> q;
	q.push({1, 1});
	vis[1][1] = 1;
	while(!q.empty())
	{
		node now = q.front();q.pop();
		if(now.x == n && now.y == m){
			ans = min(ans, now.step);
			return; 
		}
		for(int i = 0; i < 4; ++i){
			int xx = now.x + dx[i];
			int yy = now.y + dy[i];
			if(check(xx, yy) && !vis[xx][yy])
			{
				if(mp[xx][yy] == '.' || mp[xx][yy] != '*' && ok[xx][yy]){
					vis[xx][yy] = 1;
					q.push({xx, yy, now.step + 1});
				}
			}
		}
	}
}
void work()
{
	cin >> n >> m >> h;
	for(int i = 1; i <= n; ++i) cin >> (mp[i] + 1);
	for(int i = 1; i <= n; ++i)
		for(int j = 1; j <= m; ++j)
			if(mp[i][j] >= '1' && mp[i][j] <= '9')
				v.push_back({i, j});
	for(int i = 0; i < (1 << v.size()); ++i){
		memset(vis, 0, sizeof(vis));
		memset(ok, 0, sizeof(ok));
		int sum = 0;
		for(int j = v.size() - 1; j >= 0; --j) if(i & (1 << j))
			ok[v[j].first][v[j].second] = 1, sum += mp[v[j].first][v[j].second] - '0';
		if(sum >= h) continue;
		bfs();
	}
	cout << (ans == inf ? -1 : ans);
}

int main()
{
	ios::sync_with_stdio(0);
//	int TT;cin>>TT;while(TT--)
	work();
	return 0;
}

E. Bishop 2

code1：
这个代码就是比较暴力的思路，类似最短路的更新，然后加一步奇妙的优化
这个优化意思是：斜着走的过程中，我们走到一个点，当前节点无法去更新它的最短路，那么它后边的点也不会被当前点更新最短路

#include<bits/stdc++.h>
#define endl '\n'
#define ll long long
#define ull unsigned long long
#define ld long double
#define all(x) x.begin(), x.end()
#define mem(x, d) memset(x, d, sizeof(x))
#define eps 1e-6
using namespace std;
const int maxn = 2e3 + 9;
const int mod = 1e9 + 7;
const int inf = 0x3f3f3f3f;
const ll INF = 0x3f3f3f3f3f3f3f3f;
ll n, m;
int dx[4] = {1, 1, -1, -1};
int dy[4] = {1, -1, 1, -1};
ll dis[maxn][maxn];
int stx, sty, edx, edy;
char mp[maxn][maxn];
struct node{
	int x, y, step;
};
bool check(int x, int y){
	if(x < 1 || y < 1 || x > n || y > n) return 1;
	return 0;
}
void work()
{
	mem(dis, 0x3f);
	cin >> n >> stx >> sty >> edx >> edy;
	for(int i = 1; i <= n; ++i) cin >> (mp[i] + 1);
	dis[stx][sty] = 0;
	queue <node> q;
	q.push({stx, sty, 0});
	while(!q.empty()){
		node now = q.front();q.pop();
		for(int i = 0; i < 4; ++i){
			for(int j = 1; j <= n; ++j){
				int xx = now.x + j * dx[i], yy = now.y + j * dy[i];
				if(check(xx, yy) || mp[xx][yy] == '#') break;
				if(dis[xx][yy] > now.step + 1){// 最短路更新
					dis[xx][yy] = now.step + 1;
					q.push({xx, yy, now.step + 1});
				}
				else if(dis[xx][yy] < now.step + 1) break;// 奇妙的优化
			}
		}
	}
	if(dis[edx][edy] == INF) cout << -1;
	else cout << dis[edx][edy];
}

int main()
{
	ios::sync_with_stdio(0);
//	int TT;cin>>TT;while(TT--)
	work();
	return 0;
}

code2：
01 b f s 01bfs 01bfs 写法
开一个三维的 v i s [ x ] [ y ] [ o p ] vis[x][y][op] vis[x][y][op] 数组，表示 x , y x,y x,y 节点是由 o p op op 方向来的
搜索顺序就是由 o p op op 体现的
n e x t next next 节点，如果和当前节点方向相同，就不需要花费，否则花费 1 1 1，双端队列维护
如果没有 v i s vis vis 标记也能卡过去，加上这个标记快到飞起

#include<bits/stdc++.h>
#define endl '\n'
#define ll long long
#define ull unsigned long long
#define ld long double
#define all(x) x.begin(), x.end()
#define mem(x, d) memset(x, d, sizeof(x))
#define eps 1e-6
using namespace std;
const int maxn = 2e3 + 9;
const int mod = 1e9 + 7;
const int inf = 0x3f3f3f3f;
const ll INF = 0x3f3f3f3f3f3f3f3f;
ll n, m;
int dx[4] = {1, 1, -1, -1};
int dy[4] = {1, -1, 1, -1};
int dis[maxn][maxn];
int stx, sty, edx, edy;
char mp[maxn][maxn];
bool vis[maxn][maxn][4];
struct node{
	int x, y, step, op;
};
bool check(int x, int y){
	if(x < 1 || y < 1 || x > n || y > n) return 1;
	return 0;
}
void work()
{
	mem(dis, 0x3f);
	cin >> n >> stx >> sty >> edx >> edy;
	for(int i = 1; i <= n; ++i) cin >> (mp[i] + 1);
	dis[stx][sty] = 0;
	deque <node> q;
	q.push_back({stx, sty, 0, -1});
	while(!q.empty()){
		node now = q.front();q.pop_front();
		if(now.x == edx && now.y == edy){
			cout << now.step << endl;return;
		}
		if(now.op != -1){
			if(vis[now.x][now.y][now.op]) continue;
			vis[now.x][now.y][now.op] = 1;
		}
		for(int i = 0; i < 4; ++i){
			int xx = now.x + dx[i], yy = now.y + dy[i];
			if(check(xx, yy) || mp[xx][yy] == '#') continue;
			int w = (now.op != i);
			if(dis[xx][yy] >= now.step + w){
				dis[xx][yy] = now.step + w;
				if(w) q.push_back({xx, yy, now.step + 1, i});
				else q.push_front({xx, yy, now.step, i});
			}
		}
	}
	cout << -1;
}

int main()
{
	ios::sync_with_stdio(0);
//	int TT;cin>>TT;while(TT--)
	work();
	return 0;
}
__Rain
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
迷宫搜索问题最短路_使用BFS（广度优先搜索）解迷宫类问题
weixin_39914863的博客
12-27 308
在这学期的Computing for Finance in Python上有这么一道算法题：简单来说，输入一个list of lists，对于每一个位置，用0表示可经过的方块，用2表示金币，用1表示没有办法经过的blocks。要在获取到所有金币的情况下，找出从B(0,0) A的最短路径。如果这个路径不存在，则返回-1.Solutions 1：(感谢同专业的Vera Chim提供的代码，...
bfs搜索（广度优先搜索）.pptx
07-26
广度优先搜索（BFS）是一种用于遍历或搜索树或图的算法，其基本思想是从根节点出发，按照层次顺序进行探索。BFS 的特点是先访问离起点近的节点，再访问离起点远的节点，确保在深入探索之前先探索所有较近的节点。 #...
【算法】BFS广度优先搜索解决经典迷宫问题
passer__jw767的博客
09-19 416
使用BFS广度优先搜索算法的应用解决走迷宫问题 #include<bits/stdc++.h> using namespace std; int array[100][100],v[100][100]; struct point { int x; int y; int step; }; //定义方向数组 int dx[4] = {0,1,0,-1};//四个方向，右下左上 int dy[4] = {1,0,-1,0}; queue<point> r;//开拓一个point类
简单搜索--BFS--迷宫
wardel的博客
04-03 155
简单搜索–BFS–迷宫 Description 下图给出了一个迷宫的平面图，其中标记为1 的为障碍，标记为0 的为可 以通行的地方。 010000 000100 001001 110000 迷宫的入口为左上角，出口为右下角，在迷宫中，只能从一个位置走到这 个它的上、下、左、右四个方向之一。 对于上面的迷宫，从入口开始，可以按DRRURRDDDR 的顺序通过迷宫， 一共10 步。其中D、U、L、R ...
搜索入门——BFS之走迷宫
qq_40438165的博客
10-08 2339
BFS也称为宽度优先搜索，也是一种暴力搜索算法。BFS类似于以一个点为起点，一层一层向外扩展，就像是一个石子落入水里，荡起的涟漪一层一层向外散开。BFS不但可以完成DFS的功能，还能找到无权图最短路、迷宫最短路径等等。只是BFS相对于DFS而言需要借助于队列来辅助实现，实现上没有DFS那么无脑。 接下来我们看一个走迷宫的问题： 问题描述 输入： （S表示迷宫起点，T表示终点） 10 10 #S#...
BFS广度搜索(迷宫问题)
明先森
03-10 248
//迷宫问题 /* 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, */ public class BFS { private static int[][] array = { { 0, 1, 0, 0, 0 }, { 0, 1, 0, 1, 0 }, { 0, 0, 0, 0, 0 },
MATLAB源码集锦-基于BFS广度优先搜索算法代码
02-14
4. **结果处理**：根据应用需求，可以在遍历过程中记录节点的访问顺序，找到最短路径，或者完成其他相关任务。 MATLAB源码集锦可能包含以下内容： - 一个主函数，接收图的输入数据（可能是邻接矩阵或邻接表）以及...
BFS.rar_Bfs算法_bfs_广度优先_广度搜索算法_搜索算法
最新发布
09-24
- **深度优先搜索（DFS）**：与BFS不同，DFS深入探索分支，直到达到叶子节点，然后回溯。DFS在有限空间内可能更适合寻找特定路径，而在无限空间或需要找到所有解决方案时可能陷入无限循环。 - **时间复杂度**：BFS和...
PHP实现广度优先搜索算法(BFS,Broad First Search)详解
10-19
广度优先搜索（Breadth-First Search，简称BFS）是一种图遍历算法，通常用于解决寻找最短路径、树的层次遍历等问题。BFS的基本思想是从给定的起始节点开始，逐层访问节点的相邻节点，直到遍历到所有的节点。它按照...
基于python的广度优先搜索算法BFS设计与实现
05-01
在计算机科学领域，广度优先搜索（Breadth-First Search，简称BFS）是一种用于遍历或搜索树或图的算法。它按照从根节点开始，先访问所有距离根节点最近的节点，再访问距离根节点次近的节点，以此类推的顺序进行搜索...
[week2]经典迷宫问题——BFS搜索法
明哲天翊的博客
03-04 329
文章目录题意输入样例输出样例分析总结代码 题意 给定一个5*5的二维数组，0代表可以走，1代表不可以走。 输出从左上角(0,0)走到右下角(4,4)的路径。 （保证有唯一解） 输入样例 0 1 0 0 0 0 1 0 1 0 0 1 0 1 0 0 0 0 1 0 0 1 0 1 0 输出样例 (0, 0) (1, 0) (2, 0) (3, 0) (3, 1) (3, 2) (2, 2) (1,...
【搜索-BFS】逃离迷宫
大树的学习之路
07-23 399
逃离迷宫 Time Limit:1000MS     Memory Limit:32768KB     64bit IO Format:%I64d & %I64u Submit Status Description 　　给定一个m × n (m行, n列)的迷宫，迷宫中有两个位置，gloria想从迷宫的一个位置走到另外一个位置，当然迷宫中有些地方是空地，gloria可以穿越，有些地方是障碍
利用广度优先搜索（bfs）来解决迷宫问题
weixin_45843077的博客
02-19 3015
利用bfs来解决迷宫问题 #include<stdio.h> #include<string.h> #define maxsize 1000 int map[maxsize][maxsize]; int head=0,tail=1; int next[4][2]={{0,1},{1,0},{0,-1},{-1,0}}; int x1,y1,x2,y2; int w,h; s...
关于对BFS广度搜索+队列的理解
凡心所向，素履所往，生如逆旅，一苇以航
08-04 6631
1.概念：        广度优先搜索算法（Breadth-First-Search），又译作宽度优先搜索，或横向优先搜索，简称BFS，是一种图形搜索算法。简单的说，BFS是从根节点开始，沿着树的宽度遍历树的节点。如果所有节点均被访问，则算法中止。广度优先搜索的实现一般采用open-closed表。 2.解析：          如果说DFS（深度优先搜索）靠的是栈，那BFS（广度优先搜索）...
走迷宫--图的搜索（bfs）并记录路径
热门推荐
ly59782的博客
03-30 1万+
题目描述： 一个网格迷宫由n行m列的单元格组成，每个单元格要么是空地（用1表示），要么是障碍物（用0来表示）。你的任务是找一条从起点到终点的最短步数和移动序列，其中UDLR表示上下左右操作。任何时候都不能在障碍物格子中，也不能走到迷宫之外。起点和终点保证都是空地。n，m 样例输入： 6 5 11011 10111 10100 10111 11101 11111 样例输出：
基于bfs搜索算法的迷宫最短路径游戏
LiuRenyou的博客
05-26 1635
基于bfs搜索算法的迷宫最短路径游戏 废话不多说：因为在我的上一篇博客里已经提到了bfs算法.花了一天的时间写的一个小游戏，虽然界面不怎么样，但是算法确实很难写。
DFS/BFS搜索迷宫路径
长期更新Java自学笔记
05-11 1414
文章目录一、DFS搜索迷宫路径二、BFS搜索迷宫路径 一、DFS搜索迷宫路径 DFS依赖栈结构 先把左上角节点入栈，然后依次查看栈顶元素的右、下、左、上四个方向是否可以走，如果能走就把节点入栈，然后再依次查看依次查看栈顶元素的右、下、左、上四个方向；如果四个方向都不能走，就把栈顶元素出栈 最终栈空，则说明退回到了左上角的节点；右下角的节点入栈，则表示找到了出口 需要注意的是，每入栈一个节点： 需要将当前节点到入栈节点的方向置为NO，保证如果走进死胡同回退后，不会再次往这个错误的方向走 需要将刚入栈节
广度优先搜索算法BFS
qq_14952615的博客
07-29 545
本文我们主要讲BFS算法。 BFS算法搜索的时候呈现出一种 按 层 搜索的特点，即节点看起来好像被分为不同的 layer了。具体我们还是举个例子来说明。 老规矩我们先给出BFS算法的计算流程 BFS(graph G, start vertex s) [all nodes are initited as unexplored] - mark s as explored - initiate Q as a empty FIFO queue, then add s into Q -whil...
BFS问题及其讲解（迷宫）
老6
10-20 3237
广度/宽度优先搜索(BFS) 【算法入门】 郭志伟@SYSU：raphealguo(at)qq.com 2012/04/27 1.前言 广度优先搜索（也称宽度优先搜索，缩写BFS，以下采用广度来描述）是连通图的一种遍历策略。因为它的思想是从一个顶点V0开始，辐射状地优先遍历其周围较广的区域，故得名。 一般可以用它做什么呢？一个最直观经典的例子就是走迷宫，我们从起点开始，找出到终点的最短路程，很多最短路径算法就是基于广度优先的思想成立的。 算法导论里边会给出不少严格的证明，我想尽量写得通俗一点，因此采用一些直
搜索算法入门：BFS与DFS深度解析
"本文主要介绍了搜索算法的基础概念，特别是两种常用搜索策略——深度优先搜索（DFS）和宽度优先搜索（BFS），并结合迷宫问题进行了深入解析。这两种搜索方法在编程解题和实际问题中都有广泛应用。" 深度优先搜索...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值