bfs基础题型

陌上花开 ~

已于 2022-07-27 23:30:17 修改

阅读量644

点赞数 1

分类专栏： # 搜素文章标签：宽度优先算法 c语言

于 2020-09-17 22:08:40 首次发布

本文链接：https://blog.csdn.net/qq_45550375/article/details/108654243

版权

搜素专栏收录该内容

16 篇文章 0 订阅

订阅专栏

BFS介绍

宽度优先搜索算法（又称广度优先搜索）是最简便的图的搜索算法之一，这一算法也是很多重要的图的算法的原型。Dijkstra单源最短路径算法和Prim最小生成树算法都采用了和宽度优先搜索类似的思想。

其别名又叫BFS，属于一种盲目搜寻法，目的是系统地展开并检查图中的所有节点，以找寻结果。换句话说，它并不考虑结果的可能位置，彻底地搜索整张图，直到找到结果为止。

例1：迷宫（一）

题目：迷宫（一）

代码：

#include<iostream>
#include<stdio.h>
#include<queue>
#define LL long long
#define fo(i,a,b)  for(int i = a; i < b; ++i)
#define fo2(i,a,b) for(int i = a; i <= b; ++i)
#define ios ios::sync_with_stdio(false);cin.tie(0); cout.tie(0);
using namespace std;
char a[11][11];
bool vis[11][11];
int x[4]={0,0,-1,1},y[4]={1,-1,0,0};
queue <pair<int,int>> q;
int main(){
	int n,m;
	scanf("%d%d",&n,&m);
	fo2(i,1,n)fo2(j,1,m){
		cin>>a[i][j];
//		scanf("%c",&a[i][j]);有坑，会吞掉回车和空格 
		if(a[i][j]=='S')
			q.push({i,j});
	}
	while(!q.empty()){
		pair<int,int> p=q.front();  q.pop();
		int xx=p.first,yy=p.second;
		fo(i,0,4){
			int x0=x[i]+xx,y0=y[i]+yy;
			if(x0>=1 && y0>=1 && x0<=n && y0<=m && !vis[x0][y0]){
				vis[x0][y0]=1;
				if(a[x0][y0]=='T'){
					printf("yes\n");
					return 0;
				}
				else if(a[x0][y0]=='.'){
					q.push({x0,y0});
				}
			}
		}
	}
	printf("no\n");
	return 0;
}

例2：马的遍历

题目：马的遍历

题目描述

有一个n*m的棋盘(1<n,m<=400)，在某个点上有一个马,要求你计算出马到达棋盘上任意一个点最少要走几步

输入格式

一行四个数据，棋盘的大小和马的坐标

输出格式

一个n*m的矩阵，代表马到达某个点最少要走几步（左对齐，宽5格，不能到达则输出-1）

代码：

#include<cstdio>
#include<string.h>
#include<cmath>
#include<queue>
using namespace std;
struct Node{int x,y;}node,Top;
//需要从所有的16个位置中找其中8个位置
const int dx[4]={1,-1,2,-2};
const int dy[4]={1,-1,2,-2};
int a[401][401];
bool vis[401][401];
int n,m;
queue<Node> Q;
void bfs(int x,int y){
    a[x][y] = 0;
    vis[x][y] = 1;
    Q.push({x,y});
    while (!Q.empty()){
        Top=Q.front(); Q.pop();
        for (int i=0;i<4;i++)for (int j=0;j<4;j++)       
            if (abs(dx[i])!=abs(dy[j])){//判断位置
                int X=Top.x+dx[i],Y=Top.y+dy[j];
                if (X<1||X>n||Y<1||Y>m) continue;//判越界 
                //使用布尔数组保证每个点只入队一次,时间复杂度明显低于DFS
                if (!vis[X][Y]){
                    Q.push({X,Y});
                    vis[X][Y] = 1;
                    a[X][Y] = a[Top.x][Top.y]+1;//路径+1
                }
            }
    }
}
int main(){
    memset(a,-1,sizeof(a));
    int x,y;
    scanf("%d%d%d%d",&n,&m,&x,&y);
    bfs(x,y);
    for(int i=1;i<=n;i++){
        for(int j=1;j<=m;j++)
            printf("%-5d",a[i][j]);//注意场宽
        printf("\n");
    }
    return 0;
}
//%-md：输出格式为整形,长度为m(输出最小长度),左对齐

例3：绿纹龙的森林游记

在这里插入图片描述

思路：

首先读入矩阵，建议读入的时候从1开始，比0方便一些（从0当然也可以），因为bfs的思路是遍历每一个小动物，看这个小动物能不能被1-10框住，如果发现小动物能够走到边界以外的位置，也就是0或12，那么它就能够逃脱猎人的魔爪，注意这个时候数组最少要开到12，不能开到11，不然会WA （个人惨痛教训）

代码：

#include <iostream>
#include <cstdio>
#include <cmath>
#include <algorithm>
#include <queue>
#include <cstring>
#include <set>
#include <map>
#include <sstream>
#define LL long long
#define mem(f, x) memset(f,x,sizeof(f)) 
#define fo(i,a,n) for(int i=a;i<n;++i)
#define fo2(i,a,n) for(int i=a;i<=n;++i)
#define pii pair<int,int>
const int INF = 0x3f3f3f3f;
using namespace std;
template<class T>inline void read(T &x){
    x=0; char c=getchar(); bool f=0;
    while(!isdigit(c))f^=c=='-',c=getchar();
    while(isdigit(c))x=(x<<3)+(x<<1)+(c^48),c=getchar();
    if(f)x=-x;
}
int a[12][12];
int dx[4] = {0,1,0,-1},dy[4] = {1,0,-1,0};
int vis[12][12],res=0;
bool bfs(int x1,int y1){
	memset(vis,0,sizeof vis);
	queue<pii> q;
	vis[x1][y1]=1;
	q.push({x1,y1});
	while(!q.empty()){
		int xx=q.front().first,yy=q.front().second;
		q.pop();
		//到边界了,说明框不住 
		if(xx==0 || xx==11 || yy==0 || yy==11)return 1;
		fo(i,0,4){
			int x=xx+dx[i],y=yy+dy[i];
			if(a[x][y]||vis[x][y]) continue;
			pii t={x,y};
			q.push(t);
			vis[x][y]=1;
		}
	}
	return 0;
}
int main(){
	fo2(i,1,10)fo2(j,1,10)read(a[i][j]);
	fo2(i,1,10)fo2(j,1,10)
		if(!a[i][j]&&!bfs(i,j))res++;//小动物且出不去
	cout<<res<<endl;
	return 0;
}

例4：山峰和山谷

Description

Byteasar特别喜欢爬山，在爬山的时候他就在研究山峰和山谷。为了能够让他对他的旅程有一个安排，他想知道山峰和山谷的数量。
给定一个地图，为Byteasar想要旅行的区域，地图被分为 n×n 的网格，每个格子 (i,j) 的高度 w(i,j) 是给定的。

若两个格子有公共顶点，那么他们就是相邻的格子。（所以与(i,j)相邻的格子有(i−1,j−1),(i−1,j),(i−1,j+1), (i,j−1),(i,j+1), (i+1,j−1),(i+1,j),(i+1,j+1)），共8个

我们定义一个格子的集合S为山峰（山谷）当且仅当：

S的所有格子都有相同的高度
S的所有格子都联通
对于s属于S，与s相邻的s′不属于S。都有ws>ws′（山峰），或者ws<ws′（山谷）

你的任务是，对于给定的地图，求出山峰和山谷的数量，如果所有格子都有相同的高度，那么整个地图既是山峰，又是山谷。

Input

第一行包含一个正整数n，表示地图的大小（1≤n≤1000）。接下来一个n×n的矩阵，表示地图上每个格子的高度。(0≤w≤1000000000)

Output

包含两个数，分别表示山峰和山谷的数量。

Input

5
8 8 8 7 7
7 7 8 8 7
7 7 7 7 7
7 8 8 7 8
7 8 8 8 8

Output

2 1

思路：

首先读入矩阵，这里是从0开始的，本题思路是寻找可能是山峰，或可能是山谷的联通块。搜索过程中，如果格子越界了，就不再判断后续情况，否则，看它和最初格子的高度是否一样，如果一样，就把它加入队列，继续搜索，如果不一样，就可以排除山峰或者山谷了，搜索完之后，如果没有排除山谷，那一定是山谷，同理，如果没有排除山峰，那就一定是山峰了，因为边界对山峰和山谷的判断是没有限制的，包容山峰和山谷

代码：

#include <iostream>
#include <queue> 
#include <algorithm>
#define fo(i,a,n) for(int i=a;i<n;++i)
using namespace std;
template<class T>inline void read(T &x){
    x=0; char c=getchar(); bool f=0;
    while(!isdigit(c))f^=c=='-',c=getchar();
    while(isdigit(c))x=(x<<3)+(x<<1)+(c^48),c=getchar();
    if(f)x=-x;
}
const int N = 1005;
typedef pair<int,int> PII;
int g[N][N],n,res1 = 0,res2 = 0;
int dx[] = {0,0,-1,1,-1,-1,1,1};
int dy[] = {1,-1,0,0,-1,1,-1,1};
bool st[N][N];
void bfs(int x,int y){
	queue<PII> q;
    q.push({x,y});
    st[x][y] = 1;
    //flag1=1代表是山峰，flag2=1代表是山谷
    bool flag1 = 1,flag2 = 1;
    while(!q.empty()){
        PII t = q.front();q.pop();
        for(int i = 0;i < 8;i++){
            int nx=t.first+dx[i],ny=t.second+dy[i];
            if(nx < 0 || nx >= n || ny < 0 || ny >= n)  continue;
            if(g[nx][ny] != g[t.first][t.second]){
                if(g[nx][ny] < g[t.first][t.second])flag2 = 0;
                else flag1 = 0;
            }
            else if(!st[nx][ny]){
                q.push({nx,ny});
                st[nx][ny] = 1;
            }
        }
    }
    //如果没有比这块高的，那这块就是山峰 
    if(flag1)res1++;//山峰
    if(flag2)res2++;
}
int main(){
    scanf("%d",&n);
    fo(i,0,n)fo(j,0,n)
    	read(g[i][j]);
        
    fo(i,0,n)fo(j,0,n)
        if(!st[i][j])bfs(i,j);
           
    printf("%d %d\n",res1,res2);
    return 0;
}

例5：Acute Stroke

1091 Acute Stroke (30 分)

思路：

三维找满足大小范围的连通块，通过三个数组来控制方向，bfs即可，我们一般设置访问数组st和信息数组a注意遍历的顺序，最先遍历层数即可

注意遍历的时候st数组的位置

错误示范：

int bfs(int x0,int y0,int z0){
	int v=1;
	queue<str> q;
	q.push({x0,y0,z0});
	while(q.size()){
		auto t=q.front();q.pop();
		int x=t.x,y=t.y,z=t.z;
		st[x][y][z]=1; //错误示范!!!
		f(i,0,6){
			int x1=x+d[i][0],y1=y+d[i][1],z1=z+d[i][2];
			if(x1>=0&&y1>=0&&z1>=0 && x1<l&&y1<m&&z1<n && a[x1][y1][z1] && !st[x1][y1][z1]){
				v++;
				q.push({x1,y1,z1});
				cout<<x1<<" "<<y1<<" "<<z1<<endl;
			}
		}
	}
	return v;
}

错误原因：

输出中间变量，会发现有点重复进入队列，因为一层的点可能会多次访问同一个下一层的点

ac代码：

#include <bits/stdc++.h>
#define closeSync ios::sync_with_stdio(0);cin.tie(0);cout.tie(0);
#define debug(x) cout<<#x<<":"<<x<<endl;
#define f(i,a,n) for(int i=a;i<n;++i)
#define ff(i,a,n) for(int i=a;i<=n;++i)
#define IN freopen("E:\\信竞\\信竞文件夹\\in_c.TXT","r",stdin);

const int INF=0x3f3f3f3f;
using namespace std;
typedef long long ll;

const int M=1300,N=130,L=65;
int m,n,l,t;
int a[L][M][N],st[L][M][N];
//上下左右前后
int d[6][3]={{0,0,1},{0,0,-1},{0,-1,0},{0,1,0},{-1,0,0},{1,0,0}};

struct str{
	int x,y,z;
};

int bfs(int x0,int y0,int z0){
	int v=1;
	queue<str> q;
	q.push({x0,y0,z0});
	st[x0][y0][z0]=1;
	while(q.size()){
		auto t=q.front();q.pop();
		int x=t.x,y=t.y,z=t.z;
		f(i,0,6){
			int x1=x+d[i][0],y1=y+d[i][1],z1=z+d[i][2];
			if(x1>=0&&y1>=0&&z1>=0 && x1<l&&y1<m&&z1<n && a[x1][y1][z1] && !st[x1][y1][z1]){
				v++;
				q.push({x1,y1,z1});
				st[x1][y1][z1]=1;
			}
		}
	}
	return v;
}

int main(){
	//IN
	cin>>m>>n>>l>>t;
	f(i,0,l)f(j,0,m)f(k,0,n){
		cin>>a[i][j][k];
	}
	int sum=0;
	f(i,0,l)f(j,0,m)f(k,0,n){
		if(!st[i][j][k] && a[i][j][k]){
			int v=bfs(i,j,k);
			if(v>=t)sum+=v;
		}
	}
	cout<<sum<<endl;
}

陌上花开 ~

关注

1
点赞
踩
7

收藏

觉得还不错? 一键收藏
0
评论
bfs基础题型

BFS介绍宽度优先搜索算法（又称广度优先搜索）是最简便的图的搜索算法之一，这一算法也是很多重要的图的算法的原型。Dijkstra单源最短路径算法和Prim最小生成树算法都采用了和宽度优先搜索类似的思想。其别名又叫BFS，属于一种盲目搜寻法，目的是系统地展开并检查图中的所有节点，以找寻结果。换句话说，它并不考虑结果的可能位置，彻底地搜索整张图，直到找到结果为止。例1题目：迷宫（一）代码：#include<iostream>#include<stdio.h>#includ
复制链接

扫一扫

专栏目录