bfs题目代码

已于 2022-01-19 19:44:59 修改
阅读量614 收藏
点赞数
文章标签： 宽度优先 算法 c++
于 2022-01-18 13:50:45 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/karshey/article/details/122548913
版权

AcWing模板代码

#include<bits/stdc++.h>
using namespace std;
#define fir(i,a,n) for(int i=a;i<=n;i++)
#define mem(a,x) memset(a,x,sizeof(a));
typedef long long ll;
const int N=1e2+10; 
int d[N][N];
int g[N][N];
int n,m;
struct node
{
	int x,y;
};
int dx[4]={0,0,1,-1};
int dy[4]={1,-1,0,0};
int bfs()
{
	queue<node>q;
	q.push({1,1});
	mem(d,0x3f);
	d[1][1]=0;
	
	while(!q.empty())
	{
		node t=q.front();
		q.pop();
		
		for(int i=0;i<4;i++)
		{
			int xx=t.x+dx[i];
			int yy=t.y+dy[i];
			
			if(xx>=1&&xx<=n&&yy>=1&&yy<=m)
			{
				if(d[xx][yy]==0x3f3f3f3f&&g[xx][yy]==0)
				{
					d[xx][yy]=d[t.x][t.y]+1;
					if(xx==n&&yy==m)
					{				
						return d[xx][yy];
					}
					else
					{
						q.push({xx,yy});
					}
				}
			}
		}
	}
}
int main()
{
	cin>>n>>m;
	fir(i,1,n)
		fir(j,1,m)
			cin>>g[i][j];
	
	cout<<bfs();
	return 0;
}

P2802 回家

题

#include<bits/stdc++.h>
using namespace std;
#define fir(i,a,n) for(int i=a;i<=n;i++)
#define mem(a,x) memset(a,x,sizeof(a));
typedef long long ll;
const int N=10;
int g[N][N];
int n,m;
int sx,sy;
int ex,ey;
struct node
{
	int x,y,hp,ans;
};
int v[N][N];
/*标记数组，标记这个地方是否来过，
来过了就不要重复入队，
这里用血量来标记，一直存最优的血量 
*/
int dx[4]={0,0,1,-1};
int dy[4]={1,-1,0,0};
int ans;
void bfs()
{
	queue<node>q;
	q.push({sx,sy,6,0});
	v[sx][sy]=6;
	
	while(q.size())//while(!q.empty())
	{
		node t=q.front();
		q.pop();
		
		for(int i=0;i<4;i++)
		{
			int xx=t.x+dx[i];
			int yy=t.y+dy[i];
			
			if(xx>=1&&xx<=n&&yy>=1&&yy<=m)
			{
				if(g[xx][yy]!=0)
				{				
					int hpp=t.hp-1;
					if(hpp==0) continue;//没血了 
					if(v[xx][yy]>=hpp) continue;//条件更好的走过了 
					if(g[xx][yy]==3)
					{
						ans=t.ans+1;
						return;
					}
					
					else if(g[xx][yy]==4)
					{
						hpp=6;
					}
					
					//就算到了某个有鼠标的格子才死去， 他也不能通过拾取鼠标补满 HP。
					if(hpp>1) 
					{
						q.push({xx,yy,hpp,t.ans+1});					
						v[xx][yy]=hpp;//要注意 v的标记要放在可以入队的情况之下
					}					
				}
			}
		}
	}
}
int main()
{
	cin>>n>>m;
	for(int i=1;i<=n;i++)
	{
		for(int j=1;j<=m;j++)
		{
			cin>>g[i][j];
			if(g[i][j]==2)
			{
				sx=i,sy=j;
			}			
		}		
	}
	
	ans=0x3f3f3f3f;
	bfs();
	
	if(ans==0x3f3f3f3f) cout<<-1;
	else cout<<ans;
	return 0;
}

Poj 3984 迷宫问题

#include<cstdio>
#include<queue>
#include<cstring>
#include<vector>
#include<iostream>
using namespace std;
#define fir(i,a,n) for(int i=a;i<=n;i++)
#define mem(a,x) memset(a,x,sizeof(a));
typedef long long ll;
const int N=1e5+10;
int g[5][5];
struct node
{
	int x,y,xx,yy;//现在的坐标 上一个的坐标 
}; 
int v[5][5];
int dx[4]={0,0,1,-1};
int dy[4]={1,-1,0,0};
int x[5][5];
int y[5][5];
void bfs()
{
	queue<node>q;
	q.push({0,0,-1,-1});
	v[0][0]=1;
	x[0][0]=-1,y[0][0]=-1;
	while(q.size())
	{
		node t=q.front();
		q.pop();
		
		for(int i=0;i<4;i++)
		{
			int xx=t.x+dx[i];
			int yy=t.y+dy[i];
			
			if(xx>=0&&xx<=4&&yy>=0&&yy<=4)
			{
				if(v[xx][yy]==0&&g[xx][yy]==0)
				{
					v[xx][yy]=1;
					q.push({xx,yy,t.x,t.y});
					x[xx][yy]=t.x;
					y[xx][yy]=t.y;
					//cout<<t.x<<" "<<t.y<<" "<<xx<<" "<<yy<<endl;
				}
			}
		}
	}
}
struct temp
{
	int x,y;
};
vector<temp>ans;
int main()
{
	fir(i,0,4)
		fir(j,0,4)
			scanf("%d",&g[i][j]);
	
	bfs();
	int xx=4,yy=4;
	
	
	while(xx!=-1&&yy!=-1)
	{		
		ans.push_back({xx,yy});
		//cout<<xx<<" "<<yy<<endl;
		int xxx=x[xx][yy],yyy=y[xx][yy];
		xx=xxx,yy=yyy;
		//不能直接xx=x[xx][yy],yy=y[xx][yy] 
		//因为经过前面的赋值xx已经变了
		//则后面的yy就错了			
	}
	
	for(int i=ans.size()-1;i>=0;i--)
	{
		printf("(%d, %d)\n",ans[i].x,ans[i].y);
	}
	
//	//看一下xy的表 
//	fir(i,0,4)
//	{
//		fir(j,0,4)
//		{
//			cout<<x[i][j]<<","<<y[i][j]<<'\t';
//		}
//		cout<<endl;
//	}
	
	return 0;
}

P1162 填涂颜色

#include<bits/stdc++.h>
using namespace std;
#define fir(i,a,n) for(int i=a;i<=n;i++)
#define mem(a,x) memset(a,x,sizeof(a));
typedef long long ll;
const int N=30+10;
int n;
int g[N][N]; 
struct node
{
	int x,y;
};
int v[N][N];
int dx[4]={0,0,1,-1};
int dy[4]={1,-1,0,0};
void bfs(int x,int y)
{
	queue<node>q;
	q.push({x,y});
	v[x][y]=1;
	g[x][y]=2;
	while(q.size())
	{
		node t=q.front();
		q.pop();
		
		for(int i=0;i<4;i++)
		{
			int xx=t.x+dx[i];
			int yy=t.y+dy[i];
			
			if(!v[xx][yy]&&g[xx][yy]==0)
			{
				g[xx][yy]=2;
				q.push({xx,yy});
			}
		}
	}
}

void print()
{
	for(int i=1;i<=n;i++)
	{
		for(int j=1;j<=n;j++)
		{
			cout<<g[i][j]<<" ";
		}
		cout<<endl;
	}
}
int judge(int x,int y)//判断这个点在不在里面 
{
	int flag=0;
	for(int i=x;i>=1;i--)//上面是否有1 
	{		
		if(g[i][y])
		{
			flag++;
			break;
		}	
	}
	
	for(int i=x;i<=n;i++)//下 
	{
		if(g[i][y])
		{
			flag++;
			break;
		}
	}
	
	for(int j=y;j>=1;j--)//左 
	{
		if(g[x][j])
		{
			flag++;
			break;
		}
	}
	
	for(int j=y;j<=n;j++)//右 
	{
		if(g[x][j])
		{
			flag++;
			break;
		}
	}
	
	if(flag==4) return 1;
	else return 0;
} 
int main()
{
	cin>>n;
	for(int i=1;i<=n;i++)
		for(int j=1;j<=n;j++)
		{
			cin>>g[i][j];			
		}
	//print();	
	
	//用bfs把里面围的0变成2
	for(int i=1;i<=n;i++)
	{
		for(int j=1;j<=n;j++)
		{			
			if(g[i][j]==0&&judge(i,j))
			{
				bfs(i,j);//里面是连通的 所以只用bfs一次即可 
				goto endd;//也可以break两次 
			}
		}
	}
	
	endd:
		print();
	return 0;
}

P1451 求细胞数量

题

#include<bits/stdc++.h>
using namespace std;
#define fir(i,a,n) for(int i=a;i<=n;i++)
#define mem(a,x) memset(a,x,sizeof(a));
typedef long long ll;
const int N=1e2+10;
int n,m;
char mp[N][N]; 
int ans;
int v[N][N];
struct node
{
	int x,y;
};
int dx[4]={0,0,1,-1};
int dy[4]={1,-1,0,0};
void bfs(int x,int y)
{
	queue<node>q;
	q.push({x,y});
	v[x][y]=1;
	while(q.size())
	{
		node t=q.front();
		q.pop();
		
		for(int i=0;i<4;i++)
		{
			int xx=t.x+dx[i];
			int yy=t.y+dy[i];
			
			if(xx>=1&&xx<=n&&yy>=1&&yy<=m)
			{
				if(!v[xx][yy]&&mp[xx][yy]!='0')
				{
					v[xx][yy]=1;
					q.push({xx,yy});
				}
			}			
		}
	}
}

int main()
{
	cin>>n>>m;
	fir(i,1,n)
		fir(j,1,m)
			cin>>mp[i][j];
	
	ans=0;
	for(int i=1;i<=n;i++)
	{
		for(int j=1;j<=m;j++)
		{
			if(mp[i][j]!='0'&&v[i][j]==0)
			{
				v[i][j]=1;
				bfs(i,j);
				ans++;
			}
		}
	}	
	cout<<ans;
	return 0;
}
karshey
关注
二叉树BFS(代码ac)
lover_putter的博客
08-21 499
题目描述 查看题目信息 输入一串二叉树，对其从根结点开始进行BFS，输出： 1. BFS序； 2.从根结点出发到每个结点的最短路长度。 输入格式 第一行为二叉树的结点数n（n<=1000）； 之后n行，每行包含3个整数，分别为当前结点序号，以及其左右儿子序号，空格隔开。 （-1表示空结点） 保证： 1.这n行数据依次对应第1个点至第n个点； 2.第1个点为二叉树的根结点。 输出格式 两行，第一行为BFS序。 第二行从根结点出发至每个结点的最短路长...
算法——DFS、BFS【练习】
weixin_51345990的博客
09-08 335
LeetCode的刷题总结——合并二叉树、图像渲染
哈工大BFS算法代码
04-07
BFS算法的课程作业，宽度优先搜索算法（又称广度优先搜索）是最简便的图的搜索算法之一，这一算法也是很多重要的图的算法的原型。Dijkstra单源最短路径算法和Prim最小生成树算法都采用了和宽度优先搜索类似的思想
bfs代码
pureszgd的博客
06-13 453
bfs代码 #leetcode def bfs(graph, start, end): queue = [] queue.append([start]) visited.add(start) while queue: node = queue.pop() visited.add(node) process(node) nodes = generate_related_nodes(node) queue.push(nodes) # other processing work
【BFS】（代码详解）
最新发布
2301_76518242的博客
03-18 562
原文链接：https://blog.csdn.net/m0_62881629/article/details/125072287。全面学习BFS的可以参照以下路径，本文章只附上部分代码的解释作为学习记录共勉（星星眼）
BFS示例代码
海盗船
08-09 1946
#include #include using namespace std; #define MAXN 55 const int d[][2]={{1,0},{0,-1},{0,1}};//题目的坐标偏移量 struct Node//结构体保存节点信息 { int x,y,step; Node(){} Node(int a,int b,int c):x(a),y(b),step(
超简单的深度优先搜索代码
feengg的博客
05-27 5334
//深度优先搜索测试 //例： // 1 // / | \ // / | \ // 2 3---5 // | // | // 4 //step1:将存储图的方法称为图的*邻接矩阵存储法* // 通路用1表示，不通用-1表示，自身为0 // 1 2 ...
浙大ACM题目代码，最新浙大ACM题目代码
01-04
12. 树的遍历：代码中的`BFS`函数展示了如何使用队列实现广度优先遍历，这是一种常见的树或图的遍历算法。 总的来说，这些知识点涵盖了ACM竞赛的算法基础，包括动态规划、博弈论、递归、图论（最小生成树）以及数据...
ACM模板和一些题目的代码实现
02-19
2. **题目代码实现**： - **字符串处理**：涉及到字符串匹配、KMP算法、Manacher's Algorithm等，常用于文本处理类题目。 - **数学问题**：如数论问题（质因数分解、最大公约数、最小公倍数）、组合数学（排列组合...
OI、OJ、ACM、PAT、CSP 题目常用代码模板
02-23
5. **数学模板**：包括数论（质数判断、最大公约数、最小公倍数等）、组合数学（排列组合、容斥原理、鸽巢原理等）、几何（平面几何、三维几何）、线性代数等，它们在解决特定类型的题目时十分关键。 6. **字符串...
广度优先搜索(BFS)代码实现
技术进阶之路
07-16 770
Python代码实现如下： graph = { "A": ["B", "C"], "B": ["A", "C", "D"], "C": ["A", "B", "D", "E"], "D": ["B", "C", "E", "F"], "E": ["C", "D"], "F": ["D"] } def BFS(graph, s): ...
BFS/DFS 模板 代码
ltx06的专栏
05-07 559
[cpp] view plaincopyprint? "font-size:18px">#include   #include   #include   #include   using namespace std;   const int maxn=100;   bool vst[maxn][maxn]; // 访问标记   int dir[4][2]
bfs（广度优先）和dfs（深度优先）代码
qq_47060402的博客
08-07 139
本人csdn常客，不怎么发文章，今天第一次发，下面是我写的关于bfs和dfs的代码，需要的自取，原理我不讲，程序所用语言为c++，其中代码中深度优先被我注释掉了，需要深度优先的复制被注释的代码即可 #include #include #include #include using namespace std; struct MapPoint { string PointName; vector index; int piontindex; }; /void dfsfind(int havefind,Map
bfs的算法的详解（代码版）
alongwaywith的博客
02-21 6499
dfs就是所谓的深度搜索(Depth first search)，这种算法旨在解决最优问题，如最小时间，最快路径之类的。实际上bfs（广度优先搜索）也是可以解决此类问题（这个可以参考下一篇），但是鉴于题目的空间和时间的限制，你不得不选择dfs（广搜同样也能解决最优问题，但是他是将所有的结果都找出来，那么时间上你已经gg了） 简单来说，这个算法就是将地图上能走的点走一遍，找出最优的解。步骤的话，就是创建2维数组，作为地图，然后找到起点和终点，从起点开始，输入每个点。然后进行判断。这个一点是不是符合要求，然后标
BFS代码核心框架
weixin_47525457的博客
08-29 559
一、BFS：使用队列保存未被检测的点，结点按照宽度优先的次序被访问和进出队列。 下面用树来讲述BFS。 例题 牛客网NC15 import java.util.*; public class Solution { public ArrayList<ArrayList<Integer>> levelOrder (TreeNode root) { // write code here ArrayList<ArrayList<Int
18276 走迷宫 （BFS）
weixin_50340097的博客
01-23 912
同DFS的问题引入，计算迷宫中的最短路径问题：方法是通过一层一层扩展的方法来达到目标位置，扩展时每发现一个点就将这个点加入到队列中去，直到达到目标位置。这个方法的核心思路是模拟路线，每当没写一个新的可能，就把这个可能入列，直到达到位置，然后在所以的队列中，取最短的队列即可解决问题。 队列操作准备： struct note { int x;//表示横坐标 int y;//表示纵坐标 int s;//表示步数 }; struct note queue[2501];//由于地图是50*50
BFS
热门推荐
爱敲代码的小赤佬
04-19 1万+
基于邻接矩阵的广度优先搜索遍历 Problem Description 给定一个无向连通图，顶点编号从0到n-1，用广度优先搜索(BFS)遍历，输出从某个顶点出发的遍历序列。(同一个结点的同层邻接点，节点编号小的优先遍历） Input 输入第一行为整数n（0< n <100），表示数据的组数。 对于每组数据，第一行是三个整数k，m，t（0＜k＜100，0＜m＜(k-1)*k/2，0＜ ...
BFS和DFS代码实现
Yzhang001的博客
04-11 1334
BFS DFS实现图的遍历 以以下图数据为例： 首先BFS是广度优先遍历算法，从图的某一个节点出发，然后遍历完这个节点相邻的节点。这个算法的核心就是，先把周围的找完，再去找更深的地方。通俗易懂的说法：DFS就是一条路走到底，发现没路了，返回来，走另一条路。BFS就是每条路都走一点，走一点点后就走另一条路了。 在BFS遍历的时候，需要用队列将遍历的这个节点的相邻节点添加到队列中去，然后取队首，将这个节点相邻的节点加到队列中（未在队列中的），重复上述步骤。 以上面的图为例，假定我们先将A节点加入队列中，然后A
BFS 简单思想以及代码
weixin_30258901的博客
06-24 277
BFS(广搜思想) 广度优先搜索 广度优先搜索是图论的搜索算法之一，以下便进行简单叙述 对于每一个顶点来说，都存在着三种颜色 白色，灰色，黑色 而对于每个顶点，都有三种数据类型 颜色类型，前驱或者父节点，路程 分别用：color，u，d来表示 实现思想： BFS(G , s) （ G 为图，s 为初始点） struct node ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

karshey

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值