C++ 算法篇 广度（宽度）优先搜索（BFS）习题答案

已于 2023-10-30 14:03:15 修改
阅读量1.3k 收藏 7
点赞数 3
分类专栏： 习题解析 C++基础算法 文章标签： 算法 c++ 宽度优先
于 2020-08-24 10:30:51 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43736974/article/details/108194504
版权

宽度优先搜索是一种“盲目”搜索，所有结点的拓展都遵循“先进先出”的原则，所以采用“队列”来存储这些状态。宽度优先搜索的算法框架如下：

1、瓷砖

（queue写法）

#include<bits/stdc++.h>
using namespace std;
int px[4]={0,0,1,-1};
int py[4]={1,-1,0,0};
int main()
{  int h,w,a[60][60],i,j,ans=1,x,y;
   char c;   
   queue <int> dx,dy;
   cin>>h>>w;      
   for(i=1;i<=w;i++)
      for(j=1;j<=h;j++)
      {  cin>>c;
         if(c=='.')  a[i][j]=1;
         if(c=='#')  a[i][j]=0;
         if(c=='@') 
		 {  dx.push(i); dy.push(j);
		    a[i][j]=0;
		 }         
      } 
    while(!dx.empty())
    {  for(i=0;i<4;i++)
	   {  x= dx.front()+px[i];
	      y= dy.front()+py[i];
	      if(a[x][y]==1)
	      {  ++ans;
	         dx.push(x); dy.push(y);
	         a[x][y]=0;	     	
		  }
       }
	    dx.pop(); dy.pop();
	}
	cout<<ans<<endl;
	return 0;
}

（数组写法）

#include<bits/stdc++.h>
using namespace std;
int px[4]={0,0,1,-1};
int py[4]={1,-1,0,0};
int dx[200],dy[200];
int main()
{  int h,w,a[60][60],i,j,ans=1,x,y,head=0,tail=1;
   char c;     
   cin>>h>>w;      
   for(i=1;i<=w;i++)
      for(j=1;j<=h;j++)
      {  cin>>c;
         if(c=='.')  a[i][j]=1;
         if(c=='#')  a[i][j]=0;
         if(c=='@') 
		 {  dx[1]=i; dy[1]=j;
		    a[i][j]=0;
		 }         
      } 
    while(head<=tail)
    {  head++;
	   for(i=0;i<4;i++)
	   {  x= dx[head]+px[i];
	      y= dy[head]+py[i];
	      if(a[x][y]==1)
	      {  tail++;
		     ++ans;
	         dx[tail]=x; dy[tail]=y;
	         a[x][y]=0;		
		  }
       }
	}
	cout<<ans<<endl;
	return 0;
}

2、填涂颜色

#include<bits/stdc++.h>
using namespace std;
queue<int> dx,dy;
int py[2][4]={{-1,1,0,0},
              {0,0,-1,1}};
int a[32][32]={};
int main()
{   int n,i,j,x=1,y=1;
    cin>>n;
    for(i=1;i<=n;i++)
       for(j=1;j<=n;j++)   cin>>a[i][j];
    dx.push(x);
    dy.push(y);	
	 
    while(!dy.empty())
    {   for(i=0;i<4;i++) 
        {  x=dx.front()+py[0][i];  y=dy.front()+py[1][i];
		  // cout<<x<<" "<<y<<endl;        
		   if(a[x][y]==0&&x>=0&&y>=0&&x<=n+1&&y<=n+1) {  dx.push(x);dy.push(y);   a[x][y]=2; }
		}	    
		dx.pop();dy.pop();    	
	}
    for(i=1;i<=n;i++)
    {   for(j=1;j<=n;j++)  cout<<2-a[i][j]<<" ";
        cout<<endl;
	}     
}

3、求细胞数量

STL queue写法

#include<bits/stdc++.h>
using namespace std;
queue<int> dx,dy;
int py[2][4]={{-1,1,0,0},
              {0,0,-1,1}};
int a[105][105]={},ans=0;
int n,m,i,j,x,y;
char c;
void bfs(int x,int y)
{  int X,Y;   
   ans++;
   dx.push(x); dy.push(y);
   a[x][y]=0;
   while(!dy.empty())
    {   for(int i=0;i<4;i++) 
        {  X=dx.front()+py[0][i];  Y=dy.front()+py[1][i];		      
		   if(a[X][Y]) { dx.push(X);dy.push(Y);  a[X][Y]=0;}
		}	    
		dx.pop();dy.pop();    	
	}
}
int main()
{   cin>>n>>m;
    for(i=1;i<=n;i++)
       for(j=1;j<=m;j++)  { cin>>c; a[i][j]=(c!='0');   } 
	    
    for(i=1;i<=n;i++)
    {   for(j=1;j<=m;j++)      
          if(a[i][j])  bfs(i,j);  	  	  
	}   
	cout<<ans;  
}

数组写法

#include<bits/stdc++.h>
using namespace std;
int py[2][4]={{-1,1,0,0},
              {0,0,-1,1}};
int a[105][105]={},ans=0;
int n,m,i,j,x,y;
int dx[100],dy[100];
char c;
void bfs(int x,int y)
{  int X,Y,head=0,tail=1;
   ans++;
   dx[1]=x; dy[1]=y;
   a[x][y]=0;
   while(head<=tail)
    {   head++;
	    for(int i=0;i<4;i++) 
        {  X=dx[head]+py[0][i];  Y=dy[head]+py[1][i];		      
		   if(a[X][Y]) { tail++; dx[tail]=X;dy[tail]=Y;  a[X][Y]=0;}
		}		  	
	}
}
int main()
{   cin>>n>>m;
    for(i=1;i<=n;i++)
       for(j=1;j<=m;j++)  { cin>>c; a[i][j]=(c!='0');   } 
	    
    for(i=1;i<=n;i++)
    {   for(j=1;j<=m;j++)      
          if(a[i][j])  bfs(i,j);  	  	  
	}   
	cout<<ans;  
}

4、面积（area）

5、关系网络

#include<bits/stdc++.h>
using namespace std;
int i,j,n,x,y,a[101][101],t=0;
queue <int> q;
queue <int > step;
int main()
{   cin>>n>>x>>y;
    for(i=1;i<=n;i++)
	   for(j=1;j<=n;j++)
	     cin>>a[i][j];    
	int b[101]={0};
	q.push(x);
	b[x]=1;	
	step.push(0);
	while(!q.empty())
	{  for(i=1;i<=n;i++)
	   { if(a[q.front()][i]==1&& b[i]==0)
	     {   q.push(i);	          
	         step.push(step.front()+1);
	         if(i==y) {	cout<<step.front();	return 0; }	
			 b[i]=1;          
	     }
		   
	   }
	   q.pop();	
	   step.pop();
	}
}

用数组写

#include<bits/stdc++.h>
using namespace std;
int i,j,a[101][101];
int b[101],f[101],k[101];
int n,x,y,head=1,tail=1,tx;
int main()
{   cin>>n>>x>>y;
    for(i=1;i<=n;i++)
	   for(j=1;j<=n;j++)   cin>>a[i][j]; 
	b[x]=1;	f[1]=x; k[1]=0;
	while(head<=tail)
	{ tx=f[head];
	  if(tx==y) { cout<<k[head]-1; break;}	    
	  for(i=1;i<=n;i++)
	   { if(a[tx][i]==1&& b[i]==0)
	     {   tail++;         
	         f[tail]=i;
	         b[i]=1;  
			 k[tail]=k[head]+1;        
	     }
	   }
	   head++;
	}
}

6、最少经过城市

用 queue 写

#include<bits/stdc++.h>
using namespace std;
int i,j,n,a[101][101],d[101]={0},f[101]={};
queue <int> q;
int out(int x){
	if(x==0) return 0;
	cout<<char(x+64);
	if(f[x]!=0)  cout<<"--";
	return out(f[x]);
} 
int main()
{   cin>>n;
    for(i=1;i<=n;i++)
	   for(j=1;j<=n;j++)  cin>>a[i][j];    
	q.push(1);
	d[1]=1;
	while(!q.empty())
	{  for(i=1;i<=n;i++)
	     if(a[q.front()][i]==0&&d[i]==0 )
	     {  q.push(i);
	        d[i]=1;
	        if(f[i]==0)f[i]=q.front();
			if(i==n) out(n)	; 			    	
		 }		
		q.pop();
		//for(i=1;i<=n;i++) cout<<f[i]<<" ";
		//cout<<endl;   
	}
}

用数组写

#include<bits/stdc++.h>
using namespace std;
int i,j,n,a[101][101],d[101]={0},f[101]={};
int out(int x){
	if(x==0) return 0;
	cout<<char(x+64);
	if(f[x]!=0)  cout<<"--";
	return out(f[x]);
} 
int q[1001],tx;
int main()
{   cin>>n;
    for(i=1;i<=n;i++)
	   for(j=1;j<=n;j++)  cin>>a[i][j];    
	d[1]=1;
	int head=1,tail=1;
	q[1]=1;
	while(head<=tail)
	{   tx=q[head];
	    for(i=1;i<=n;i++)
	     if(a[tx][i]==0&&d[i]==0 )
	     {  tail++;
	        q[tail]=i;
	        d[i]=1;
	        if(f[i]==0)f[i]=q[head];
			if(i==n) out(n)	; 			    	
		 }		
		head++;
		//for(i=1;i<=n;i++) cout<<f[i]<<" ";
		//cout<<endl;   
	}
}

7、营救

#include<bits/stdc++.h>
using namespace std;
struct hhh
{	int h,l,s;//行，列，步数 
}qwq[1000005];
int jz[1005][1005]={0},d[1005][1005]={0};
int	main()
{	int bh[4][2]={{0,1},{1,0},{0,-1},{-1,0}};
	int head,tail,ax,ay,bx,by,flag=0,n,nx,ny;
	char ch;
	scanf("%d",&n);
	for(int i=1;i<=n;i++)
	{   getchar();getchar();
		for(int j=1;j<=n;j++)  jz[i][j]=getchar()-'0';  
	}
	scanf("%d %d %d %d",&ax,&ay,&bx,&by);	
	head=1;tail=1;//队列初始化 
	qwq[tail].h=ax;
	qwq[tail].l=ay;
	qwq[tail].s=0;
	tail++;
	d[ax][ay]=1;
	while(head<tail)
	{	for(int i=0;i<4;i++)
		{	nx=qwq[head].h+bh[i][0];
			ny=qwq[head].l+bh[i][1];
			if(nx<1||nx>n||ny<1||ny>n)	continue;
			if(jz[nx][ny]==0&& d[nx][ny]==0)
			{   d[nx][ny]=1;				
				qwq[tail].h=nx;//入队 
				qwq[tail].l=ny;
				qwq[tail].s=qwq[head].s+1;
				tail++;				
			}
			if(nx==bx&&ny==by)	flag=1;break;
		}
		if(flag==1)	break;
		head++;//不管有没有新成员入队都要对已有的成员出队操作 
	}//tail指向队尾（最后一个元素的下一个位置，所以-1） 	
	cout<<qwq[tail-1].s<<endl;	return 0;
}

8、最少转弯问题（TURN）

流年llyz
关注
  • 3
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
c++宽度搜索详解
Yoyo的博客
02-25 317
从计算机科学专业上讲，宽度优先搜索算法（又称广度优先搜索）是最简便的图的搜索算法之一，这一算法也是很多重要的图的算法的原型。地图格子上隐藏一只熊猫，骑士从左上角开始搜索。骑士每次只能搜索上下左右四个格子，看看骑士是怎样搜索的？不过要编程实现这个方法时，一般不是这样“二维平面”上处理，而是进一步分解为“一格一格”的简单处理。宽度优先搜索其英文全称是Breadth First Search，简称BFS。宽度搜索的特点是先看“四周”。例如：骑士在方格地图上搜索迷雾中隐藏的熊猫，1. 什么是宽度搜索。
【C++广度搜索入门】面积
JaneSilver的博客
08-14 2236
毫无意义的前言   我的蒟蒻之路终于走到了搜索这一关！经历了深搜懵逼后来到了广搜懵逼态。广搜第一题就卡了我一天。。。各位巨佬们别笑，是真的。。。算法的理解从1到2很容易，但是从0到1很难。了解BFS（广搜）还要顺带着了解队列什么的。。。就用这道题纪念我的广搜历程吧，希望能帮到有困难有需要的人。同时抛砖引玉，如果其他做法欢迎在评论区讨论。 真希望我C++不要从入门到入土233333 题目 问...
2024年C C++最新C++算法——BFS（图解，面试篇
2401_84978525的博客
05-13 268
就是因为这个性质，先到达的那条路线一定是步数最少的，所以只要有一条路线走到了，那么它一定就是最短路线，直接返回，所以这个算法非常快（重点！重点！重点！
[C++]广度优先搜索（BFS）（附例题）
热门推荐
stary_yan的博客
05-08 3万+
广度优先搜索（BFS）（附例题）问题产生：Isenbaev是国外的一个大牛。现在有许多人要参加ACM ICPC。一共有n个组，每组3个人。同组的3个人都是队友。大家都想知道自己与大牛的最小距离是多少。大牛与自己的最小距离当然是0。大牛的队友和大牛的最小距离是1。大牛的队友的队友和大牛的最小距离是2……以此类推。如果实在和大牛没有关系的只好输出undefined了。第一行读入n。表示有n个组。1 ≤
C++教程004--符号和一道题
liudabai__的博客
11-29 1472
教程延续
关系网络
a_streaker的博客
05-24 2101
大家好 //先赞后看，已成习惯 这是一道有关于BFS的题目 广度优先搜索！！！ 知识补充—— 宽度优先搜索算法(又称广度优先搜索)是最简便的图的搜索算法之一，这一算法也是很多重要的图的算法的原型。Dijkstra单源最短路径算法和Prim最小生成树算法都采用了和宽度优先搜索类似的思想。 目的是系统地展开并检查图中的所有节点，以找寻结果。换句话说，它并不考虑结果的可能位置，彻底地搜索整张图，直到找到结果为止。 不足之处多多指教！！！ 谢谢给位大佬！！！ 代码如下—— #include<cstdio&
代码 基于BFS广度优先搜索算法代码
06-04
代码 基于BFS广度优先搜索算法代码代码 基于BFS广度优先搜索算法代码代码 基于BFS广度优先搜索算法代码代码 基于BFS广度优先搜索算法代码代码 基于BFS广度优先搜索算法代码代码 基于BFS广度优先搜索算法代码代码 ...
基于Python的图搜索算法实现：广度优先搜索BFS，Dijkstra 算法，贪心最佳优先搜索，A*搜索
04-19
该代码实现了广度优先搜索BFS，Dijkstra 算法，贪心最佳优先搜索，A*搜索，并提供了将搜索结果画图展示的接口。 在入口文件处，提供了如何调用各类算法的例子以及演示了使用画图接口的方法。
MATLAB源码集锦-基于BFS广度优先搜索算法代码
02-14
MATLAB源码集锦-基于BFS广度优先搜索算法代码
python广度优先搜索算法（BFS）
最新发布
05-22
广度优先搜索（BFS）是另一种用于遍历或搜索树或图的算法。在BFS中，我们首先访问起始节点，然后逐层访问其所有邻居节点，就像一圈一圈向外扩展的波纹一样。在访问完当前层的所有节点之前，不会进入下一层。 在...
广度优先搜索（BFS），算法中的拓荒者！.zip
04-11
bfs广度优先搜索（BFS）是一种计算机科学中的算法，用于遍历或搜索树或图。它通过从起始节点开始，逐层向外扩展，直到找到目标节点或遍历完所有节点。BFS算法保证了在遍历过程中，先访问的节点具有较小的深度。 BFS...
关系网络c++
mwssx的博客
03-31 370
关系网络c++
BFS的常见算法题-二叉树的最小深度
张凡的博客
07-31 280
BFS的使用
并查集(C++) -- 关系网
sal.keZ
04-16 697
并查集并查集(C++) -- 关系网并查集 -- 基本思路实现并查集 -- 优化实现 并查集(C++) – 关系网   并查集，并就是组件关系网，查就是查找关系网中的成员；通俗来理解就是A和B交朋友，A和B就形成了一个AB的关系网，A和C交朋友，ABC就成了一个关系网，因为B可以通过A认识C，以此类推；所以并查集关心的是哪些成员是相互联系的，不管是直接的还是间接的；   一个集合总要有个老大才能表...
【算法】BFS算法练习
xing1584114471的博客
07-10 589
（一）问题描述: 给定一个字符串以及多个子串，对于在字符串中出现的子串可以多次移除，求多次移除后能够得到的最短字符串长度。 输入: 第一行为一个字符串，第二行为多个子串，字符串长度大于0 输出: 多次移除后能够得到的最短字符串长度 示例1: 输入: 第一行："ccdaabcdbb" 第二行：["ab","cd"] 输出: 第一行：2 解释: ccdaabcdbb ...
BFS宽度优先搜索C++
m0_73857526的博客
03-04 203
关于bfs小姐姐
广度优先算法 LeetCode102 题解
王小明的专栏
05-30 216
def BFS(graph, start, end)： queue = [] queue.append([start]） visited. add(start) while queue: node=quede.pop() visited.add(node) process(node） nodes = generate_related_nodes(node) queue. push(nodes) 给你一个二叉树，请你返回其按 层
BFS经典例题—迷宫问题
llzhh的博客
04-05 1万+
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表示可以走的路，只能横着走或竖着走，不能斜着走，要求编程序找出从左上角到右下角的最短
BFS 算法框架
wolfGuiDao的博客
04-18 1687
BFS 算法框架 文章目录BFS 算法框架一、BFS算法框架二、二叉树的最小高度三、解开密码锁的最少次数四、双向 BFS BFS 的核心思想应该不难理解的，就是把一些问题抽象成图，从一个点开始，向四周开始扩散。一般来说，我们写 BFS 算法都是用「队列」这种数据结构，每次将一个节点周围的所有节点加入队列。 BFS 相对 DFS 的最主要的区别是：BFS 找到的路径一定是最短的，但代价就是空间复杂度...
图的遍历（搜索）算法（深度优先算法DFS和广度优先算法BFS）
05-30
好的，关于图的遍历算法，我可以为您简要介绍一下。 图是由节点和边组成的一种数据结构，其中节点表示实体，边表示节点之间的关系。遍历图的目的是访问图中的每个节点，以便了解它们之间的关系。 深度优先算法（DFS）是一种递归算法，它从起点开始沿着一条路径一直遍历到底，直到无法继续为止，然后回溯到前一个节点并选择另一条路径继续遍历。这个过程一直持续到所有节点都被访问为止。DFS的时间复杂度为O(V+E)，其中V表示节点数，E表示边数。 广度优先算法（BFS）是一种迭代算法，它从起点开始，首先访问与起点相邻的所有节点，然后依次访问与这些节点相邻的未访问节点，直到所有节点都被访问为止。BFS使用队列来存储待访问的节点，先进先出。BFS的时间复杂度为O(V+E)。 这就是关于图的遍历算法的简单介绍，希望能对您有所帮助。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值