蓝桥杯算法练习笔记(10)__广度优先搜索 BFS

最新推荐文章于 2022-03-31 20:08:36 发布
最新推荐文章于 2022-03-31 20:08:36 发布
阅读量594 收藏 4
点赞数 2
分类专栏： # 蓝桥杯练习笔记 文章标签： 算法 bfs dfs 队列
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/A233666/article/details/104835222
版权

10.广度优先搜索 BFS在这里插入图片描述

1.队列queue
#include<iostream>
#include<queue>
using namespace std;

int main(){
	queue<int> q;
	q.push(1);
	q.push(2);
	q.push(3);
	cout<<q.front()<<endl;//1
	q.pop();
	if(!q.empty()){
		cout<<q.front()<<endl;//2
	}
	//队列没有clear()方法,可以这样清空
	while(!q.empty() ){
		q.pop();
	}
	return 0;
}
2.书院主持人

北大附中书院有m个同学，他们每次都很民主地决策很多事情。按罗伯特议事规则，需要一个主持人。同学们民主意识强，积极性高，都想做主持人，当然主持人只有一人。为了选出主持人，他们想到了一个办法并认为很民主。方法是：大家围成一圈，从1到m为每个同学编号。然后从1开始报数， 数到n的出局。剩下的同学从下位开始再从1开始报数。最后剩下来的就是主持人了。现在已经把同学从1到m编号，并约定报数为n的出局，请编程计算一下，哪个编号的同学将会成为主持人。

#include<iostream>
#include<queue>
using namespace std;

int main() {
	int n,m;
	cin>>n>>m;
	queue<int> q;
	for(int i=1;i<=n;i++){
		q.push(i);
	}
	int cur=1;
	while(q.size()>1){
		int x=q.front();
		q.pop();
		if(cur!=m){
			q.push(x);
			cur++;
		} else{
			cur=1;
		}
	}
	cout<<q.front()<<endl;
}
3.迷宫问题

对于DFS要枚举所有的可能性，如果地图过大，那么效率很低

对于BFS是分层搜索，因此第一次搜索到终点时，当前搜素的层数就是最短路径的长度

#include<iostream>
#include<queue> 
using namespace std;
int n,m;
char maze[105][105];
bool vis[105][105];
int dir[4][2]={{-1,0},{0,-1},{1,0},{0,1}};//方向
bool in(int x,int y){//范围
	return x>=0 && x<n && y>=0 && y<m;
}
//节点
struct node{
	int x,y,d;
	node(int xx,int yy,int dd){
		x=xx;
		y=yy;
		d=dd;
	}
};

int bfs(int sx,int sy){
	queue<node> q;
	q.push(node(sx,sy,0));
	vis[sx][sy]=true;
	while(!q.empty()){
		node now=q.front();
		q.pop();
		for(int i=0;i<4;i++){
			int tx=now.x+dir[i][0];
			int ty=now.y+dir[i][1];
			if(in(tx,ty) && maze[tx][ty]!='*' && !vis[tx][ty]){
				if(maze[tx][ty]=='T'){
					return now.d +1; 
				}else{
					vis[tx][ty]=true;
					q.push(node(tx,ty,now.d+1));
				}
			}
		}
	} 
	return -1;
}

int main(){
	cin>>n>>m;
	for(int i=0;i<n;i++){
		for(int j=0;j<m;j++){
			cin>>maze[i][j];
		}
	}
	
	int x,y;
	for(int i=0;i<n;i++){
		for(int j=0;j<m;j++){
			if(maze[i][j]=='S'){
				x=i;
				y=j;
			}
		}
	}
	
	cout<<bfs(x,y)<<endl; 
	
	return 0;
}

/*
样例输入：
5 6
....S*
.**...
.*..*.
*..**.
.T....

样例输出： 
7

*/
4.一维坐标的移动
/*在长度为【0，n】的一维坐标中，输入A，B的地址，问能否从A到B。
移动方式：向前一步(坐标+1)，向后一步(坐标-1)，跳（坐标*2）*/
#include<iostream>
#include<queue>
#include<utility>
using namespace std;
bool vis[100];
int main() {
	int n,A,B,now,step;
	cin>>n>>A>>B;

	queue< pair<int,int> >q;
	q.push(make_pair(A,0));
	vis[A]=true;
	while(!q.empty()) {
		
		now=q.front().first;
		step=q.front().second;
		
		q.pop();
		if(now==B){
			cout<<step<<endl;
			break;
		}
		if(now+1<=n && !vis[now+1]) {
			q.push(make_pair(now+1,step+1));
			vis[now+1]=true;
		}
		if(now-1>=0 && !vis[now-1]) {
			q.push(make_pair(now-1,step+1));
			vis[now-1]=true;
		}
		if(now*2<=n && !vis[now*2]) {
			q.push(make_pair(now*2,step+1));
			vis[now*2]=true;
		}
	}


	return 0;
}
/*
样例输入：
10 2 7
样例输出
3
*/
5.密码锁

在这里插入图片描述

#include<iostream>
#include<queue>
#include<algorithm>
#include<cstring>
using namespace std;

struct node {
	int num[4],step;
} first,last;

int vis[11][11][11][11];

void bfs() {
	int i;
	node a,next;
	queue<node> q;
	a=first;
	a.step=0;
	q.push(a);
	memset(vis,0,sizeof(vis));
	vis[a.num[0]][a.num[1]][a.num[2]][a.num[3]]=1;
	while(!q.empty()) {
		a=q.front();
		q.pop();
		//bfs出口
		if(a.num[0]==last.num[0] && a.num[1]==last.num[1]
		        &&a.num[2]==last.num[2] &&a.num[3]==last.num[3] ) {
			cout<<a.step<<endl;
			return;
		}
		for(int i=0; i<4; i++) { //++1
			next=a;
			next.num[i]++;
			if(next.num[i]==10) {
				next.num[i]=1;
			}
			if(!vis[next.num[0]][next.num[1]][next.num[2]][next.num[3]]) {
			vis[next.num[0]][next.num[1]][next.num[2]][next.num[3]]=1;
				 next.step++;
				 q.push(next);
			}
		}

		for(int i=0; i<4; i++) { //--1
			next=a;
			next.num[i]--;
			if(next.num[i]==0) {
				next.num[i]=9;
			}
			if(!vis[next.num[0]][next.num[1]][next.num[2]][next.num[3]]) {
			vis[next.num[0]][next.num[1]][next.num[2]][next.num[3]]=1;
				 next.step++;
				 q.push(next);
			}
		}

		for(int i=0; i<3; i++) {//交换 
			next=a;
			next.num[i]=a.num[i+1];
			next.num[i+1]=a.num[i];
			if(!vis[next.num[0]][next.num[1]][next.num[2]][next.num[3]]) {
			vis[next.num[0]][next.num[1]][next.num[2]][next.num[3]]=1;
				 next.step++;
				 q.push(next);
			}
		}

	}
}



int main() {
	int i,j,k;
	char s1[10],s2[10];
	cin>>s1>>s2;
	for(int i=0; i<4; i++) {
		first.num[i]=s1[i]-'0';
		last.num[i]=s2[i]-'0';
	}
	bfs();

	return 0;
}

/*
样例输入：
1234
2144
样例输出：
2
*/
6.三阶平面魔方

在这里插入图片描述

#include<iostream>
#include<map>
#include<queue>
#include<cstdio>
using namespace std;

struct node{
	int a[3][3];
	bool operator < (const node &x) const{
		for(int i=0;i<3;i++){
			for(int j=0;j<3;j++){
				if(a[i][j]<x.a[i][j]){
					return 1;
				}
			}
		}
		return 0;
	}
	
	bool operator == (const node &x) const{
		for(int i=0;i<3;i++){
			for(int j=0;j<3;j++){
				if(a[i][j]!=x.a[i][j]){
					return 0;
				}
			}
		}
		return 1;
	}
	void print(){
		for(int i=0;i<3;i++){
			for(int j=0;j<3;j++){
				cout<<a[i][j]<<" ";
			}
			cout<<endl;
		}
	}
	int tonum(){
		int res=0;
		for(int i=0;i<3;i++){
			for(int j=0;j<3;j++){
				res=res*10+a[i][j];
			}
		}
		return res;
	}
	
} init;

node rotate(node a,int s,int d){
	node res=a;
	if(d==-1){ //right move
		int tmp=res.a[s][2];
		res.a[s][2]=res.a[s][1];
		res.a[s][1]=res.a[s][0];
		res.a[s][0]=tmp;
	}else if(d==1){ // left move
		int tmp=res.a[s][0];
		res.a[s][0]=res.a[s][1];
		res.a[s][1]=res.a[s][2];
		res.a[s][2]=tmp;
	}else if(d==-2){ //up move
		int tmp=res.a[0][s];
		res.a[0][s]=res.a[1][s];
		res.a[1][s]=res.a[2][s];
		res.a[2][s]=tmp;
	} else if(d==2){ // down move
		int tmp=res.a[2][s];
		res.a[2][s]=res.a[1][s];
		res.a[1][s]=res.a[0][s];
		res.a[0][s]=tmp;
	}
	return res;
}

int bfs(node st){
	queue<node> q;
	map<int,int> d;
	q.push(st);
	d[st.tonum()]=0;
	while(!q.empty()){
		node x=q.front();
		q.pop();
		int tt=x.tonum();
		if(x==init){
			return d[x.tonum()];
		}
		node tmp;
		for(int i=0;i<3;i++){
			tmp=rotate(x,i,-1);
			if(!d.count(tmp.tonum())){
				d[tmp.tonum()]=d[tt]+1;
				q.push(tmp);
			}
			tmp=rotate(x,i,1);
			if(!d.count(tmp.tonum())){
				d[tmp.tonum()]=d[tt]+1;
				q.push(tmp);
			}
		}
		for(int i=0;i<3;i++){
			tmp=rotate(x,i,-2);
			if(!d.count(tmp.tonum())){
				d[tmp.tonum()]=d[tt]+1;
				q.push(tmp);
			}
			tmp=rotate(x,i,2);
			if(!d.count(tmp.tonum())){
				d[tmp.tonum()]=d[tt]+1;
				q.push(tmp);
			}
		}
	}
	return -1;
} 


int main(){
	for(int i=0;i<3;i++){
		for(int j=0;j<3;j++){
			init.a[i][j]=i*3+j+1; 
		}
	}
	node t;
	for(int i=0;i<3;i++){
		int n;
		cin>>n;
		t.a[i][2]=n%10;
		n/=10;
		t.a[i][1]=n%10;
		n/=10;
		t.a[i][0]=n;
	}
	int ans=bfs(t);
	cout<<ans<<endl;
	return 0;
}

/*
样例输入：
412
756
389
样例输出： 
2 

*/
7.吃糖的时间在这里插入图片描述
#include<iostream>
#include<queue>
#include<vector>
#include<cstdlib>
using namespace std;

typedef struct{
	int v;
	int step;
}node;

int maxn;
queue<node> q;
vector<int> g[100010];
bool vis[100010];

void bfs(){
	int i;
	node p,t;
	while(!q.empty()){
		p=q.front();
		q.pop();
		for(int i=0;i<g[p.v].size();i++){
			t.v=g[p.v][i];
			t.step=p.step+1;
			if(!vis[t.v]){
				q.push(t);
				vis[t.v]=1;
				if(t.step>maxn){
					maxn=t.step;
				}
			}
		}
	} 
	
	
	
}

int main(){
	node t;
	int n,p,c,m,a,b,i;
	cin>>n>>p>>c;
	cin>>m;
	for(int i=0;i<p;i++){
		cin>>a>>b;
		g[a].push_back(b);
	    g[b].push_back(a);
	}
	t.v=c;
	t.step=1;
	vis[t.v]=1;
	q.push(t);
	bfs();
	cout<<maxn+m<<endl;
	return 0;	
}
/*
样例输入：
4 3 1
2 
1 2
2 3
1 4
样例输出：
5 

*/
耿鬼不会笑
关注
  • 2
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
基于队列的宽度优先搜索算法(BFS)
zhanghw的博客
05-09 395
一、说明 BFS，其英文全称是Breadth First Search。 BFS并不使用经验法则算法。从算法的观点，所有因为展开节点而得到的子节点都会被加进一个先进先出的队列中。一般的实验里，其邻居节点尚未被检验过的节点会被放置在一个被称为 open 的容器中（例如队列或是链表），而被检验过的节点则被放置在被称为 closed 的容器中。（open-closed表） 二、代码 #ifndef CYCLEQUEUE_H #define CYCLEQUEUE_H #include <iostream&g
蓝桥杯官网练习题和测评数据-算法训练1-40(40题)
04-06
蓝桥杯练习题概览 试题集名称 试题总数 更新时间 入门训练 4 2013/10/9 基础练习 30 2013/11/3 算法训练 180 2018-03-09 算法提高 220 2018-03-09 历届试题 55 2017-12-18 包括题目和测试数据
蓝桥杯复习——广度优先搜索总结
My Struggle
03-18 479
前些日子在刷DFS（深度优先搜索）的题目，而最近在练习BFS（广度优先搜索），现在我对我这一段时间的学习做个总结。BFS类似于树的层次遍历，而DFS则是类似树的先根遍历。我拍了《算法C实现》这本书的讲解，作为BFS的示意图，看的顺序是从上到下，从左到右，如下所示： BFS会使用到队列这个数据结构，队列是一个先进先出的数据结构。队列是作为一个缓冲区而存在的。先将当前遍历的节点弹出队列，再将所有...
bfs——练习demo2(20届周新杰提供)
红目香薰
03-19 788
广度优先搜索 和深搜不同广搜会沿着树的高度和宽度对节点进行依次遍历 从树的根节点a开始，会发现a的子节点有c、d、f三个子节点，进程会先对这三个节点进行访问然后再访问其的子节点 对c、d、f完成访问之后进行则会探寻这三个节点的子节点并对其进行遍历，可以从图中看出他们的子节点有c、g、e 可以看出c、g、e没有子节点了所以程序对其遍历之后随之结束 package test; import java.util.LinkedList; import java.util.Queue; public...
蓝桥杯省赛专题训练之双指针、BFS与图论（相关真题和模板题）
记录一些刷过的题并分享学习心得
03-31 920
题目：1238. 日志统计 题解：双指针。 #include <bits/stdc++.h> using namespace std; typedef long long LL; typedef pair<int ,int > PII; const int N=1e5+10; int n,d,k; PII a[N]; //queue<int> q[N]; int ct[N]; bool sta[N]; int main() { cin>>n>&gt
【蓝桥杯Java真题详解】长草（BFS题型练习）
疼疼蛇的博客
04-04 1008
长草 题目描述 小明有一块空地，他将这块空地划分为 n 行 m 列的小块，每行和每列的长度都为 1。 小明选了其中的一些小块空地，种上了草，其他小块仍然保持是空地。 这些草长得很快，每个月，草都会向外长出一些，如果一个小块种了草，则它将向自己的上、下、左、右四小块空地扩展， 这四小块空地都将变为有草的小块。请告诉小明，k 个月后空地上哪些地方有草。 输入 输入的第一行包含两个整数 n, m。 接下来 n 行，每行包含 m 个字母，表示初始的空地状态，字母之间没有空格。如果为小数点，表示为空地，如果字母为 g
BFS.rar_Bfs算法_bfs_广度优先_广度搜索算法_搜索算法
最新发布
09-24
**广度优先搜索（BFS）算法详解** 广度优先搜索（BFS）是一种用于遍历或搜索树或图的算法。它从根节点开始，然后遍历所有相邻的节点，然后再对每个相邻节点进行相同的操作，直到遍历完所有节点。在图中，BFS算法...
蓝桥杯算法知识及练习题.zip_算法 蓝桥杯_蓝桥杯_蓝桥杯入门题_蓝桥杯算法题
09-21
搜索算法则涵盖了深度优先搜索（DFS）和广度优先搜索（BFS），这些是解决树形结构和图问题的常用方法。动态规划是一种解决复杂问题的有效手段，通过将大问题分解为小问题，求解最优解。 "蓝桥杯入门题"是为初学者...
matlab_suddenoka_stuckky8_广度优先搜索_bfs_
10-03
在IT领域，尤其是在计算机科学和算法设计中，广度优先搜索（BFS）是一种非常重要的图遍历算法。本文将详细解析"matlab_suddenoka_stuckky8_广度优先搜索_bfs_"这个主题，以及相关的代码实现。 首先，我们要理解广度...
erchashu.rar_bfs_erchashu_树的 深度优先 广度优先
09-23
本文利用C语言实现了简单的二叉树，每个结点只保存一个整数，并且，由于非常简单，树的根结点是确定的，而不是输入的。...建立好二 叉 树以后，分别利用深度优先（DFS）和广度优先（BFS）进行了遍历，输出结果。
BFS.rar_BFS JAVA_Bfs算法_bfs java_java b
09-24
在这个压缩包中，重点是探讨了Java语言实现图的广度优先搜索（Breadth First Search, BFS）算法。BFS是一种用于遍历或搜索树或图的算法，其基本思想是从起始节点开始，沿着树的宽度优先遍历树的节点，而不是深入到某...
＜蓝桥杯＞BFS广度优先搜索习题总结
zesong2019的博客
04-09 267
预备知识 BFS代码框架
算法基础课2021-8-21
supreme567的博客
08-22 418
#include <iostream> #include <cstring> #include <algorithm> using namespace std; int n; int st[10000]; int vis[10]; typedef pair<int, int> PII; PII way[10]; int path[10][10]; int c[10][10]; void dfs(int x){ if(x>n){
试题 算法训练 kAc给糖果你吃
一个喜欢刷算法题的工科生的博客
03-12 375
问题描述 　　kAc有n堆糖果，每堆有A[i]个。 　　kAc说你只能拿m次糖果，聪明的你当然想要拿最多的糖果来吃啦啦啦~ 　　//第二天，kAc问你还想吃糖果么？（嘿嘿嘿）说着眼角路出奇怪的微笑... 输入格式 　　第一行两个数字n和m，第二行有n个数字A[i]。 输出格式 　　输出一行表示最多能拿几个糖果。 样例输入 2 2 1 2 样例输出 3 数据规模和约定 　　0<n≤1000 　　其余数字都是不超过1,000,000,000的非负整数。 #include <
蓝桥杯算法竞赛系列第八章——提高篇之广度优先搜索（BFS）
热门推荐
安然无虞的博客
12-12 1万+
欢迎回到：遇见蓝桥遇见你，不负代码不负卿！ 【前言】 搜索算法在蓝桥中考的还是比较频繁的，之前发表了二叉树数据结构以及深度优先搜索章节，前面还是比较简单的，这里的广度优先搜索可能稍微复杂那么一丢丢，因为要用到队列，不过我们可以使用STL容器也是很方便就解决了。 【声明】：由于前半部分是基础知识点定义部分，所以前半部分赘述笔者是参考力扣官方给出的定义以及《算法笔记》一书。 一、广度优先搜索算法（BFS） 对于广度优先搜索的定义及特点，力扣官方是这样给出的： 广度优...
2016春季练习——bfs简单题
kiss forever
03-28 395
BFS一水
分酒--第三届蓝桥杯预赛真题 java本科组 第10题
易水寒(C/C++)
05-10 3521
题目：     泊松是法国数学家、物理学家和力学家。他一生致力科学事业，成果颇多。有许多著名的公式定理以他的名字命名，比如概率论中著名的泊松分布。     有一次闲暇时，他提出过一个有趣的问题，后称为：“泊松分酒”。在我国古代也提出过类似问题，遗憾的是没有进行彻底探索，其中流传较多是：“韩信走马分油”问题。     有3个容器，容量分别为12升，8升，5升。其中12升中装
【算法】蓝桥杯dfs深度优先搜索之排列组合总结
midnight_time的博客
03-21 3647
  上一篇文章 → 《【算法】蓝桥杯dfs深度优先搜索之凑算式总结》   为了重申感谢之意，再次声明下文的大部分灵感均来自于【CSDN】梅森上校《JAVA版本：DFS算法题解两个例子（走迷宫和求排列组合数）》   强烈大家去上面那篇文章看看，写的很好。   下面我会列出蓝桥杯第六届B组省赛第7题、第七届第5题、第八届第4题，共3道题。   因为他们都是：排列组合。 【第一道题】   这道题可以强...
2019蓝桥杯大学B组E题（BFS+路径记忆）
H4ppyD0g的博客
04-28 416
题目描述 下图给出了一个迷宫的平面图，其中标记为 1 的为障碍，标记为 0 的为可 以通行的地方。 010000 000100 001001 110000 迷宫的入口为左上角，出口为右下角，在迷宫中，只能从一个位置走到这 个它的上、下、左、右四个方向之一。 对于上面的迷宫，从入口开始，可以按DRRURRDDDR 的顺序通过迷宫， 一共 10 步。其中 D、U、L、R 分别表示向下、向上、向左、向右...
广度优先搜索算法.doc
05-06
"本文档主要介绍了广度优先搜索（BFS）算法，它是计算机科学中用于解决搜索问题的一种方法。文档内容涵盖了搜索法的基本概念、应用背景以及BFS算法的原理和特点。" 广度优先搜索（BFS）是一种在图或树结构中搜索...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值