Acwing 蓝桥杯备战（第四天 BFS和并查集专题）

已于 2022-04-04 21:41:09 修改
阅读量322 收藏 1
点赞数
分类专栏： 算法 文章标签： 蓝桥杯 算法
于 2022-03-30 19:35:24 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/cxiaodi/article/details/123848817
版权

注意：只有每个边的权值都相同时，才能用bfs求最短路。

走迷宫

请添加图片描述思路分析
求最短路，采用bfs算法

#include<bits/stdc++.h>
using namespace std;
const int N=110;
int g[N][N];
int dis[N][N];
typedef pair<int,int> PII;
#define x first
#define y second
int n,m;
int bfs(PII start,PII end){
    memset(dis,-1,sizeof dis);
    queue<PII> q;
    dis[start.x][start.y]=0;
    q.push(start);
    while(q.size()){
        auto a=q.front();
        q.pop();
        int dx[4]={0,1,0,-1},dy[4]={1,0,-1,0};
        for(int i=0;i<4;i++){
            int x=a.x+dx[i];
            int y=a.y+dy[i];
            if(x<1||x>n||y<1||y>m) continue; //越界
            if(g[x][y]==1) continue; //障碍
            if(dis[x][y]!=-1) continue; //已经被扩展
            dis[x][y]=dis[a.x][a.y]+1;
            if(x==n&&y==m) return dis[x][y];
            q.push({x,y});
        }
    }
}
int main(){
    scanf("%d%d",&n,&m);
    
    PII start,end;
    
    for(int i=1;i<=n;i++){
        for(int j=1;j<=m;j++){
            scanf("%d",&g[i][j]);
        }
    }
    
    start={1,1},end={n,m};
    
    int distance=bfs(start,end);
    
    printf("%d",distance);
    return 0;
}

献给阿尔吉侬的花束

请添加图片描述

#include<bits/stdc++.h>
using namespace std;
const int N=210;
char g[N][N];
int dis[N][N];
typedef pair<int,int> PII;
#define x first
#define y second
int t,n,m;
int bfs(PII start,PII end){
    memset(dis,-1,sizeof dis);
    queue<PII> q;
    dis[start.x][start.y]=0;
    q.push(start);
    while(q.size()){
        auto a=q.front();
        q.pop();
        int dx[4]={-1,0,1,0},dy[4]={0,1,0,-1};
        for(int i=0;i<4;i++){
            int x=a.x+dx[i];
            int y=a.y+dy[i];
            if(x<0||x>=n||y<0||y>=m) continue; //越界
            if(g[x][y]=='#') continue; //障碍
            if(dis[x][y]!=-1) continue; //被扩展过
            dis[x][y]=dis[a.x][a.y]+1;
            if(end==make_pair(x,y)) return dis[x][y];
            q.push({x,y});
        }
    }
    return -1;
}
int main(){
    PII start,end;
    scanf("%d",&t);
    while(t--){
        scanf("%d%d",&n,&m);
        for(int i=0;i<n;i++){
            scanf("%s",g[i]);
        }
        
        for(int i=0;i<n;i++){
            for(int j=0;j<m;j++){
                if(g[i][j]=='S') start={i,j};
                if(g[i][j]=='E') end={i,j};
            }
        }
        
        int distance=bfs(start,end);
        if(distance==-1) printf("oop!\n");
        else printf("%d\n",distance);
    }
    return 0;
}

水桶传递队列

请添加图片描述

#include<bits/stdc++.h>
using namespace std;
const int N=15;
char g[N][N];
int dis[N][N];
typedef pair<int,int> PII;
#define x first
#define y second
int bfs(PII start,PII end){
    memset(dis,-1,sizeof dis);
    queue<PII> q;
    q.push(start);
    dis[start.x][start.y]=0;
    while(q.size()){
        auto a=q.front();
        q.pop();
        int dx[4]={0,1,0,-1},dy[4]={1,0,-1,0};
        for(int i=0;i<4;i++){
            int x=a.x+dx[i];
            int y=a.y+dy[i];
            if(g[x][y]=='R') continue;
            if(x<0||x>=10||y<0||y>=10) continue;
            if(dis[x][y]!=-1) continue;
            dis[x][y]=dis[a.x][a.y]+1;
            if(end==make_pair(x,y)) return dis[x][y];
            q.push({x,y});
        }
    }
}
int main(){
    PII start,end;
    
    for(int i=0;i<10;i++) scanf("%s",g[i]);
    
    for(int i=0;i<10;i++){
        for(int j=0;j<10;j++){
            if(g[i][j]=='L') start={i,j};
            if(g[i][j]=='B') end={i,j};
        }
    }
    
    int distance=bfs(start,end);
    
    printf("%d",distance-1);
    return 0;
}

红与黑

请添加图片描述思路分析：
bfs实现FloodFill算法。

#include<bits/stdc++.h>
using namespace std;
const int N=25;
char g[N][N];
int n,m;
typedef pair<int,int> PII;
#define x first
#define y second
int bfs(int sx,int sy){
    queue<PII> q;
    q.push({sx,sy});
    int cnt=0;
    g[sx][sy]='#';
    int dx[4]={0,1,0,-1},dy[4]={1,0,-1,0};
    while(q.size()){
        auto a=q.front();
        q.pop();
        cnt++;
        for(int i=0;i<4;i++){
            int x=a.x+dx[i];
            int y=a.y+dy[i];
            if(x<0||x>=n||y<0||y>=m) continue;
            if(g[x][y]!='.') continue;
            g[x][y]='#';
            q.push({x,y});
        }
    }
    return cnt;
}
int main(){
    int x,y;
    while(cin>>m>>n,n||m){
        for(int i=0;i<n;i++) cin>>g[i];
        
        for(int i=0;i<n;i++){
            for(int j=0;j<m;j++){
                if(g[i][j]=='@'){
                    x=i;
                    y=j;
                }
            }
        }
        
        cout<<bfs(x,y)<<endl;
    }
    
    return 0;
}

思路分析：
dfs实现FloodFill算法

#include<bits/stdc++.h>
using namespace std;
const int N=25;
char g[N][N];
int n,m;
int dx[4]={0,1,0,-1},dy[4]={1,0,-1,0};
int dfs(int sx,int sy){
    int cnt=1;
    g[sx][sy]='#';
    for(int i=0;i<4;i++){
        int x=sx+dx[i];
        int y=sy+dy[i];
        if(x<0||x>=n||y<0||y>=m) continue;
        if(g[x][y]!='.') continue;
        g[x][y]='#';
        cnt+=dfs(x,y);
    }
    return cnt;
}
int main(){
    int x,y;
    while(cin>>m>>n,n||m){
        for(int i=0;i<n;i++) cin>>g[i];
        
        for(int i=0;i<n;i++){
            for(int j=0;j<m;j++){
                if(g[i][j]=='@'){
                    x=i;
                    y=j;
                }
            }
        }
        
        cout<<dfs(x,y)<<endl;
    }
    
    return 0;
}

全球变暖

请添加图片描述

思路分析：
先用bfs求出图中的所有连通块的数量，在bfs的同时，用bound变量记录会被淹没的大陆数量，total记录所有的大陆数量，如果两者相等则该岛屿会被完全淹没。

#include<bits/stdc++.h>
using namespace std;
const int N=1010;
char g[N][N];
bool vis[N][N];
int n,cnt;
int total,bound;
typedef pair<int,int> PII;
#define x first
#define y second
void bfs(int sx,int sy){
    int dx[4]={0,-1,0,1},dy[4]={1,0,-1,0};
    queue<PII> q;
    q.push({sx,sy});
    vis[sx][sy]=1;
    while(q.size()){
        auto a=q.front();
        q.pop();
        total++;
        bool is_bound=false;
        for(int i=0;i<4;i++){
            int x=a.x+dx[i];
            int y=a.y+dy[i];
            if(x<0||x>=n||y<0||y>=n) continue;
            if(vis[x][y]) continue;
            if(g[x][y]=='.'){
                is_bound=1;
                continue;
            }
            vis[x][y]=1;
            q.push({x,y});
        }
        if(is_bound) bound++;
    }
}
int main(){
    scanf("%d",&n);
    
    for(int i=0;i<n;i++) scanf("%s",g[i]);
    
    for(int i=0;i<n;i++){
        for(int j=0;j<n;j++){
            if(vis[i][j]==0&&g[i][j]=='#'){
                total=0,bound=0;
                bfs(i,j);
                if(total==bound)
                    cnt++;
            }
        }
    }
    
    printf("%d",cnt);
    return 0;
}

合并集合

请添加图片描述思路分析：
并查集的板子，p[x]中存储的该结点的父节点，注意理解find函数中的路径压缩。

#include<iostream>
using namespace std;
const int N=1e5+10;
int p[N];
int n,m;
int find(int x){
    if(p[x]!=x) p[x]=find(p[x]);
    return p[x];
}
int main(){
    scanf("%d%d",&n,&m);
    for(int i=1;i<=n;i++) p[i]=i; //初始化，开始之前每个结点指向自己
    
    while(m--){
        string s;
        int a,b;
        cin>>s;
        if(s=="M"){
            cin>>a>>b;
            a=find(a),b=find(b);
            if(a!=b){
                p[a]=b;
                //a的祖先结点不等于b的祖先结点，两者不在一个集合，让a的祖先结点的父节点指向b的祖先
            }
        }else{
            cin>>a>>b;
            a=find(a),b=find(b);
            if(a==b){
                printf("Yes\n");
            }else{
                printf("No\n");
            }
        }
    }
    return 0;
}

连通块中点的数量

请添加图片描述思路分析：
借助并查集维护一个连通块，如果a，b的祖先结点不相等说明不在同一个连通块内，
用cnt数组存储联通块中点的数量，如果将a和b之间连接一条边相当于合并两个集合，此时b连通块点的数量应该加上a中点的数量。

#include<iostream>
using namespace std;
const int N=1e5+10;
int p[N],cnt[N];
int n,m;
int find(int x){
    if(p[x]!=x) p[x]=find(p[x]);
    return p[x];
}
int main(){
    scanf("%d%d",&n,&m);
    
    for(int i=1;i<=n;i++){
        p[i]=i;
        cnt[i]=1;
    }
    
    while(m--){
        string s;
        cin>>s;
        int a,b;
        if(s=="C"){
            cin>>a>>b;
            a=find(a),b=find(b);
            if(a!=b){
                p[a]=b;
                cnt[b]+=cnt[a];
            }
        }else if(s=="Q1"){
            cin>>a>>b;
            a=find(a),b=find(b);
            if(a==b) printf("Yes\n");
            else printf("No\n");
        }else{
            scanf("%d",&a);
            a=find(a);
            printf("%d\n",cnt[a]);
        }
    }
    return 0;
}

合根植物

请添加图片描述请添加图片描述思路分析：
借助并查集维护植物集合，如果两个植物不在同一个集合（就是不合根）则按要求合并两个集合，处理完毕后记录根节点的数目。

#include<bits/stdc++.h>
using namespace std;
const int N=1e6+10;
int p[N];
int n,k,m;
int find(int x){
	if(p[x]!=x) p[x]=find(p[x]);
	return p[x];
}
int ans;
int main(){
	scanf("%d%d",&n,&m);
	n*=m;
	scanf("%d",&k);
	for(int i=1;i<=n;i++) p[i]=i;
	while(k--){
		int a,b;
		scanf("%d%d",&a,&b);
		int pa=find(a),pb=find(b);
		if(pa!=pb){
			p[pa]=pb;
		}
	}
	for(int i=1;i<=n;i++){
		if(p[i]==i) ans++;
	} 
	printf("%d",ans);
	return 0;
}

修改数组

请添加图片描述

#include<bits/stdc++.h>
using namespace std;
const int N=1000010;
int p[N];
int find(int x){
    if(p[x]!=x) p[x]=find(p[x]);
    return p[x];
}
int n;
int main(){
    scanf("%d",&n);
    for(int i=1;i<N;i++) p[i]=i;
    
    while(n--){
        int x;
        scanf("%d",&x);
        x=find(x);
        printf("%d ",x);
        p[x]=x+1;
    }
    return 0;
}
cl1mb3r
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
算法 DFS BFS 并查集
aha_bear的博客
09-30 161
算法 DFS BFS 并查集题目描述DFS解法BFS解法并查集解法 题目描述 这是一道leetcode上非常经典的题（岛屿数量），解决思路也很多。 DFS解法 DFS解法是用染色的方法，我们遍历每一个节点，每个节点都做这样的事：首先判断岛屿是否被拜访过，没被拜访过则先将岛屿数加一，再利用DFS搜索的方法，将与它连接在一起的每个节点都标记为拜访过，。这样在遍历第一个节点的时候会将与第一个节点相连的节点全都标记为拜访过，之后即使再碰到也会认为属于第一个节点的集群。 //author: Solitude //d
【NOIP 2015 D1 T2】信息传递（图论--带权并查集/bfs）
weixin_33716941的博客
11-17 92
题目：有n个同学（编号为1到n）正在玩一个信息传递的游戏。在游戏里每人都有一个固定的信息传递对象，其中，编号为i的同学的信息传递对象是编号为Ti同学。游戏开始时，每人都只知道自己的生日。之后每一轮中，所有人会同时将自己当前所知的生日信息告诉各自的信息传递对象（注意：可能有人可以从若干人那里获取信息，但是每人只会把信息告诉一个人，即自己的信息传递对象）。当有人从别人口中得知自己的生日时，游戏结束。请...
算法-图/DFS/BFS/并查集-岛屿数量
迷路剑客个人博客
05-12 355
算法-图/DFS-课程表 1 题目概述 1.1 题目出处 https://leetcode-cn.com/problems/number-of-islands 1.2 题目描述 给你一个由 ‘1’（陆地）和 ‘0’（水）组成的的二维网格，请你计算网格中岛屿的数量。 岛屿总是被水包围，并且每座岛屿只能由水平方向或竖直方向上相邻的陆地连接形成。 此外，你可以假设该网格的四条边均被水包围。 示例 1: 输入: 11110 11010 11000 00000 输出: 1 示例 2: 输入: 11000 11000
省份数量（DFS/BFS/并查集）
默默无闻但不碌碌无为
03-14 847
分析：该题属于求无向图中的连通域的个数 类的题目，面对该种题目，我们通常可以选择的方法有DFS/BFS/并查集 我们使用图搜索算法从各个连通域的任一顶点开始遍历整个连通域，遍历的过程中对 visited 数组进行标记，遍历完当前连通域之后，若仍有顶点未被访问，说明又是一个新的连通域，使用 cnt 累计当前遍历过的连通域的数量 简单来说就是遇到一个没搜索过的城市，我们就DFS/BFS它，然后把所有与该城市相联系的城市的visited标记，然后再回去看还有没有没被标记的城市，如果有...
计蒜客 - T2026 -- 信息传递【求最小环长 ：bfs + 并查集 or Trajan】
qq_45249273的博客
08-17 249
思路1：bfs + 并查集 题意很简单，画个图就知道是求最小环长，利用并查集将v认u为父亲，最终在个集合里面的根节点都是起始结点。最后走一个bfs或者dfs就能跑出答案。 AC代码 #include<cstdio> #include<iostream> #include<vector> #include<queue> #include<cstring> #include<algorithm> using namespace std;
并查集_并查集_洛谷_
09-29
并查集是一种在图论和数据结构中常用的算法，主要用于处理一些不相交集合的合并与查询问题。在洛谷这个知名的在线编程平台上有许多关于并查集的例题，这些题目非常适合初学者用来入门并查集的学习。 并查集的主要...
蓝桥杯备战 算法与数据结构的学习路线和各种题解
04-13
搜索算法包括深度优先搜索（DFS）和广度优先搜索（BFS），适用于遍历树和图。动态规划是一种优化的分治策略，常用于解决背包问题、最长公共子序列等问题。贪心算法则是每一步都采取局部最优解，适用于资源分配问题。...
src.rar_ Binary search java_KMP_PKU_java pku_并查集算法
09-23
标题中的“src.rar_ Binary search java_KMP_PKU_java pku_并查集算法”揭示了这个压缩包的内容，它包含了一些与计算机科学和编程相关的Java实现，特别是针对PKU（北京大学）的数据结构和算法题目。这个压缩包的核心...
2018蓝桥杯备战
04-02
总结，2018年蓝桥杯备战的练习集是学习和提升编程竞赛技能的重要资源，它涵盖了编程竞赛所需的基本知识和实战经验。通过深入研究这些程序，可以提升解决问题的能力，为参加类似竞赛做好充分准备。
第十三届蓝桥杯Java C组试题
04-09
【标题】"第十三届蓝桥杯Java C组试题"涵盖了两个主要编程语言——Java和C，在这个竞赛中，参赛者需要展示他们在编程、算法设计和问题解决上的技能。蓝桥杯是一项全国性的软件和信息技术专业人才大赛，旨在促进高校...
acwing21并查集
weixin_50909982的博客
03-22 138
合并集合 一共有 n 个数，编号是 1∼n，最开始每个数各自在一个集合中。 现在要进行 m 个操作，操作共有两种： M a b，将编号为 a 和 b 的两个数所在的集合合并，如果两个数已经在同一个集合中，则忽略这个操作； Q a b，询问编号为 a 和 b 的两个数是否在同一个集合中； 输入格式 第一行输入整数 n 和 m。 接下来 m 行，每行包含一个操作指令，指令为 M a b 或 Q a b 中的一种。 输出格式 对于每个询问指令 Q a b，都要输出一个结果，如果 a 和 b 在同一集合内，则输出.
C++ 并查集
YMWM_的博客
08-10 641
C++并查集
（蓝桥真题）推导部分和（图论+并查集+bfs/带权并查集）
AC__dream的博客
03-04 267
蓝桥真题
DFS和BFS和并查集的 存档
呜啦啦
02-08 314
上：(x-1,y) 下：(x+1,y) 左：(x,y-1) 右：(x,y+1) 构造2个方向数组dx[]={-1,1,0,0}，dy[]={0,0,-1,1}; for(int i=0;i {      int nx=x+dx[i];      int ny=y+dy[i]; } void dfs(...........)       //参数就是当前点坐标 {  
2/10 并查集+bfs+dfs+最短路径+spfa队列优化
weixin_51934288的博客
02-10 223
做了一个好题： 最长路径+链式前向星+spfa #include <bits/stdc++.h> using namespace std; const int inf=0x3f3f3f3f; const int maxn=1e5+5; int head[maxn],d,p,c,f,s,cnt,pp[maxn],dis[maxn]; bool vis[maxn],flag; struct node { int to,dis,nxt; }e[maxn]; void add_edge(int
算法设计与分析 实验五 图论——桥
上山打老虎的博客
06-14 5998
桥一、实验目的与要求1、实验基本要求：2、实验亮点：二、实验内容与方法三、实验步骤与过程（一）基准算法1、算法思想：2、时间复杂度分析：3、编程实现：（二）高效算法1、数据结构介绍：2、引入最近公共祖先（Least Common Ancestors，LCA）3、算法思想：4、算法实现：5、时间复杂度分析：6、编程实现：（三）正确性验证（四）时间效率对比分析1、给定数据下时间效率：2、随机数据下的时间效率：四、实验结论或体会五、思考1、 选择编译优化：2、选择BFS（广度优先搜索）进行边的加入： 一、实验目的
矩阵遍历（DFS、BFS、并查集）
qq_35789269的博客
07-19 1656
有 n 个城市，其中一些彼此相连，另一些没有相连。如果城市 a 与城市 b 直接相连，且城市 b 与城市 c 直接相连，那么城市 a 与城市 c 间接相连。 省份 是一组直接或间接相连的城市，组内不含其他没有相连的城市。 给你一个 n x n 的矩阵 isConnected ，其中 isConnected[i][j] = 1 表示第 i 个城市和第 j 个城市直接相连，而 isConnected[i][j] = 0 表示二者不直接相连。 返回矩阵中 省份 的数量。 示例 1： 输入：isConn.
DFS和BFS之间的比较
To the beyond and infinity!
08-24 4130
一、深度优先搜索（dfs）的特点是： （1）深度优先搜索法有递归以及非递归两种设计方法。一般的，当搜索深度较小、问题递归方式比较明显时，用递归方法设计好，它可以使得程序结构更简捷易懂。当数据量较大时，由于系统堆栈容量的限制，递归容易产生溢出，用非递归方法设计比较好。 （2）深度优先搜索方法有广义和狭义两种理解。广义的理解是，只要最新产生的结点（即深度最大的结点）先进行扩展的方法，就称为深度优先搜索...
Xcode Playgrounds：探索Swift编程的交互式乐园
最新发布
2401_85763803的博客
07-12 484
Playgrounds为开发者提供了一个轻量级、交互式的开发环境，你可以在这里快速尝试Swift语言的新特性，验证算法逻辑，或者仅仅是学习Swift编程。Xcode Playgrounds是一个功能丰富的交互式开发环境，它为Swift编程提供了即时反馈和无需编译的便利。无论是学习Swift语言、验证算法逻辑，还是进行快速原型开发，Playgrounds都是一个不可或缺的工具。通过本文的介绍和示例，你应该已经对Playgrounds有了深入的了解，现在就打开Xcode，开始你的Playgrounds之旅吧！
「JOISC 2014 Day2」交朋友 并查集+BFS
09-19
这个问题可以通过并查集和BFS算法来解决。首先，我们可以使用并查集来维护每个节点所在的集合。每次添加一条新的边时，我们可以找到这条边的两个节点所在的集合，并将它们合并成一个集合。通过这样的操作，我们可以...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值