AcWing.算法提高课_BFS中的Flood Fill和最短路模型

最新推荐文章于 2024-09-10 15:28:21 发布
最新推荐文章于 2024-09-10 15:28:21 发布
阅读量338 收藏
点赞数
分类专栏： AcWing算法提高课 文章标签： 算法 宽度优先 c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wazsja/article/details/126118168
版权

文章目录

BFS性质

（1）便于“求最小”；第一次到达某点为到达该点的最短路径
（2）基于迭代，不会“爆栈”

BFS主要求解问题种类

（1）最短距离：地图某一点到另一点的最短距离
（2）最小步数：地图某一种状态到另一种状态的最小步数

模型一：Flood Fill

特点：可以在线性时间复杂度内找到某点所在的连通块

主要解决问题：计算连通块数量&大小

例题一

AcWing.1097池塘计数
题目要求:计算连通块个数
思路：遍历池塘中的每个点，若为池塘，则池塘数量加一，后找出并标记该池塘的所有位置
实现代码：

#include<iostream>
#include<algorithm>
#include<cstring>
#include<queue>

using namespace std;

#define x first
#define y second

const int N = 1010;

typedef pair<int,int> PII;

int n,m;
char g[N][N];
int cnt;
bool st[N][N];

int dx[] = {1, 0, -1, 0, -1, -1, 1, 1};
int dy[] = {0, 1, 0, -1, -1, 1, -1, 1};

void bfs(int a, int b){
    cnt ++;

    queue<PII> q;

    q.push({a,b});
    while(q.size()){
        auto t = q.front();
        q.pop();

        for(int i = 0; i < 8; i ++)
            for(int j = 0; j < 8; j ++){
                int x = t.x + dx[i], y = t.y + dy[i];
                if(x >= 0 && x < n && y >= 0 && y < m && g[x][y] == 'W'){
                    q.push({x,y});
                    g[x][y] = '.';//防止重复查找
                }
            }
    }
}

int main()
{
    cin>>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] == 'W') bfs(i,j);

    cout<<cnt<<endl;

    return 0;
}

作者：Duktig_7
链接：https://www.acwing.com/activity/content/code/content/3877790/
来源：AcWing
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。
例题二

AcWing1098.城堡问题
题目要求：计算连通块个数与大小
思路：
在这里插入图片描述
实现代码

#include<iostream>
#include<algorithm>
#include<cstring>

using namespace std;

const int N = 55,M = N * N;

typedef pair<int,int> PII;

#define x first
#define y second

int n, m;
int g[N][N];
PII q[M];
bool st[N][N];

int bfs(int sx, int sy){
    int dx[] = {0, -1, 0, 1}, dy[] = {-1, 0, 1, 0};

    int hh = 0, tt = -1;
    q[++ tt] = {sx, sy};
    st[sx][sy] = true;

    int area = 0;

    while(hh <= tt){
        PII t = q[hh ++];
        area ++;

        for(int i = 0; i < 4; i ++){
            int a = t.x + dx[i], b = t.y + dy[i];
            if(a < 0 || a >= n || b < 0 || b >= m) continue;
            if(st[a][b]) continue;
            if(g[t.x][t.y] >> i & 1) continue;

            q[++ tt] = {a, b};
            st[a][b] = true;
        }
    }

    return area;
}

int main()
{
    cin >> n >> m;
    for(int i = 0; i < n; i ++)
        for(int j = 0; j < m; j ++)
            cin >> g[i][j];

    int cnt = 0, area = 0;
    for(int i = 0; i < n; i ++)
        for(int j = 0; j < m; j ++)
            if(!st[i][j]){
                area = max(area, bfs(i,j));
                cnt ++;
            }

    cout << cnt << endl << area << endl;

    return 0;
}

作者：Duktig_7
链接：https://www.acwing.com/activity/content/code/content/3973495/
来源：AcWing
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。
例题三

AcWing1106.山峰与山谷
题目要求：判断某连通块是否符合要求并计算连通块个数
思路：遍历每个点，找出该连通块中的所有点并标记，若符合要求则计数

#include<iostream>
#include<algorithm>
#include<cstring>

using namespace std;

const int N = 1010,M = N * N;

#define x first
#define y second

typedef pair<int,int> PII;

int n;
int h[N][N];
bool st[N][N];
PII q[M];

void bfs(int sx, int sy, bool& has_higher, bool& has_lower){
    int hh = 0, tt = -1;
    q[++ tt] = {sx, sy};
    st[sx][sy] = true;

    while(hh <= tt){
        PII t = q[hh ++];

        for(int i = t.x - 1; i <= t.x + 1; i ++)
            for(int j = t.y - 1; j <= t.y + 1; j ++){
                if(i == t.x && j == t.y) continue;
                if(i < 0 || i >= n || j < 0 || j >= n) continue;
                if(h[i][j] != h[t.x][t.y]){
                    if(h[i][j] > h[t.x][t.y]) has_higher = true;
                    else has_lower = true;
                }
                else if(!st[i][j]){
                    q[++ tt] = {i, j};
                    st[i][j] = true;
                }
            }
    }
}

int main()
{
    cin >> n;

    for(int i = 0; i < n; i ++)
        for(int j = 0; j < n; j ++)
            cin >> h[i][j];

    int peak = 0, valley = 0;
    for(int i = 0;i < n; i ++)
        for(int j = 0; j < n; j ++)
            if(!st[i][j]){
                bool has_higher = false, has_lower = false;
                bfs(i, j, has_higher, has_lower);
                if(!has_higher) peak ++;
                if(!has_lower) valley ++;
            }

    cout << peak << " " << valley << endl;
}

作者：Duktig_7
链接：https://www.acwing.com/activity/content/code/content/3970289/
来源：AcWing
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

模型二：最短路模型

BFS->搜到某点时，得到起点到该点的最短路
->线性时间复杂度得到所有点到起点的最短路
需要满足：所有边权重相等
主要解决问题：到达某点的最短距离

例题一

AcWing1076.迷宫问题
题目要求：到达地图某点的最短距离以及最短路
解题关键点or技巧：
（1）记录最短路路径：标记到达每个点的前一个点，由此倒推得最短路径
（2）从(n-1,n-1)位置倒推至起点->倒推得最短路径时为从真实起点出发

(1)下一步：dx[] = {-1, 0, 1, 0};dy[] = {0, 1, 0, -1};
(2)判断条件：
①越出边界不合法：if(a < 0 || a >= n || b < 0 || b >= n) continue;
②遍历过不合法：if(pre[a][b].x != -1) continue;
③地图上是墙不合法：if(g[a][b]) continue;

#include<iostream>
#include<algorithm>
#include<cstring>

using namespace std;

const int N = 1010, M = N * N;

#define x first
#define y second

typedef pair<int,int> PII;

int n;
int g[N][N];
PII q[M];
PII pre[N][N];

void bfs(int sx, int sy){
    int dx[] = {-1, 0, 1, 0},dy[] = {0, 1, 0, -1};

    int hh = 0, tt = -1;
    q[++ tt] = {sx,sy};

    memset(pre, -1, sizeof pre);
    pre[sx][sy] = {0, 0};

    while(hh <= tt){
        PII t = q[hh ++];

        for(int i = 0; i < 4; i ++){
            int a = t.x + dx[i], b = t.y + dy[i];

            if(a < 0 || a >= n || b < 0 || b >= n) continue;
            if(pre[a][b].x != -1) continue;
            if(g[a][b]) continue;

            q[++ tt] = {a,b};
            pre[a][b] = t;
        }
    }
}

int main()
{
    cin >> n;

    for(int i = 0; i < n; i ++)
        for(int j = 0; j < n; j ++)
            cin >> g[i][j];

    bfs(n - 1, n - 1);

    PII end(0, 0);

    while(1){
        cout << end.x << ' ' << end.y << endl;
        if(end.x == n - 1 && end.y == n - 1) break;
        end = pre[end.x][end.y];
    }

    return 0;
}

作者：Duktig_7
链接：https://www.acwing.com/activity/content/code/content/3971429/
来源：AcWing
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。
例题二

AcWing188.武士风度的牛
题目要求：到达地图某点的最短距离

(1)下一步：dx[] = {-2, -1, 1, 2, 2, 1, -1, -2};dy[] = {1, 2, 2, 1, -1, -2, -2, -1};
(2)判断条件：
①越出边界不合法：if(a < 0 || a >= n || b < 0 || b >= m) continue;
②题目给出障碍物不合法：if(g[a][b] == ‘*’) continue;
③遍历过不合法：if(dist[a][b] != -1) continue;

#include<iostream>
#include<algorithm>
#include<cstring>

using namespace std;

const int N = 155, M = N * N;

#define x first
#define y second

typedef pair<int,int> PII;

int n,m;
char g[N][N];
PII q[M];
int dist[N][N];

int bfs(){
    int dx[] = {-2, -1, 1, 2, 2, 1, -1, -2};
    int dy[] = {1, 2, 2, 1, -1, -2, -2, -1};

    int sx, sy;

    for(int i = 0; i < n; i ++)
        for(int j = 0; j < m; j ++)
            if(g[i][j] == 'K')
                sx = i, sy = j;

    int hh = 0, tt = -1;
    q[++ tt] = {sx, sy};

    memset(dist, -1, sizeof dist);
    dist[sx][sy] = 0;

    while(hh <= tt){
        PII t = q[hh ++];

        for(int i = 0; i < 8; i ++){
            int a = t.x + dx[i], b = t.y + dy[i];

            if(a < 0 || a >= n || b < 0 || b >= m) continue;
            if(g[a][b] == '*') continue;
            if(dist[a][b] != -1) continue;
            if(g[a][b] == 'H') return dist[t.x][t.y] + 1;

            dist[a][b] = dist[t.x][t.y] + 1;
            q[++ tt] = {a, b};
        }
    }

    return -1;
}

int main()
{
    cin >> m >> n;

    for(int i = 0; i < n; i ++) cin >> g[i];

    cout << bfs() << endl;

    return 0;
}

作者：Duktig_7
链接：https://www.acwing.com/activity/content/code/content/3971694/
来源：AcWing
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。
例题四

AcWing 1100.抓住那头牛
题目要求：计算到达一维坐标系某点的最短距离

(1)下一步：(x + 1)、(x - 1)、(x * 2)
(2)判断条件：
①x - 1：(x - 1 >= 0 && dist[x - 1] == -1)
②x + 1:(x + 1 < N && dist[x + 1] == -1)
③x * 2:(x * 2 < N && dist[x * 2] == -1)

#include<iostream>
#include<algorithm>
#include<cstring>

using namespace std;

const int N = 100010;

int n,k;
int q[N];
int dist[N];

int bfs(){
    memset(dist, -1, sizeof dist);

    int hh = 0, tt = -1;
    q[++ tt] = n;

    dist[n] = 0;

    while(hh <= tt){
        int x = q[hh ++];

        if(x == k) return dist[k];

        if(x - 1 >= 0 && dist[x - 1] == -1){
            q[++ tt] = x - 1;
            dist[x - 1] = dist[x] + 1;
            // dist[x - 1] = dist[x] + 1;
            // q[++ tt] = x - 1;
        }
        if(x + 1 < N && dist[x + 1] == -1){
            q[++ tt] = x + 1;
            dist[x + 1] = dist[x] + 1;
            // dist[x + 1] = dist[x] + 1;
            // q[++ tt] = x + 1;
        }
        if(x * 2 < N && dist[x * 2] == -1){
            q[++ tt] = x * 2;
            dist[x * 2] = dist[x] + 1;
            // dist[x * 2] = dist[x] + 1;
            // q[++ tt] = x * 2;
        }
    }

    return -1;
}

int main()
{
    cin >> n >> k;

    cout << bfs() << endl;

    return 0;
}

作者：Duktig_7
链接：https://www.acwing.com/activity/content/code/content/3973170/
来源：AcWing
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。
hheMing
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
bfs最短路与最小步数模型
m0_49959202的博客
09-20 246
文章目录bfs最短路与最小步数模型1. 算法分析2. 例题2.1 最短路2.2 最小步数2.2.1 基础最小步数模型2.2.3 有条件的最小步数模型2.2.3 卡内存+有条件的最小步数模式2.2.4 思维最小步数 bfs最短路与最小步数模型 1. 算法分析 最短路:从A点走到B点的最小距离 最小步数:从状态A到状态B的最小变化数，本质就是最短路 2. 例题 2.1 最短路 acwing1076迷宫问题 题意： 给定N*N数组，每个元素只有0和1，求从(0, 0)走到(n - 1, n - 1)的最短路，输出
带你学习Flood Fill算法与最短路模型
「 虚幻私塾」
01-21 1164
Python微信订餐小程序课程视频 https://edu.csdn.net/course/detail/36074 Python实战量化交易理财系统 https://edu.csdn.net/course/detail/35475 一、Flood Fill（连通块问题） 0.简介 Flood Fill（洪水覆盖） 可以在线性的时间复杂内，找到某个点所在的连通块！ 注：基于宽搜的思想，深搜也可以做但可能会爆栈 flood fill算法DFS与BFS： ​ DFS：无法求解最短路问题；可能会爆栈（递
最短路模型(bfs)
wmy0217_的博客
07-15 1147
文章目录AcWing 1076. 迷宫问题AcWing 188. 武士风度的牛AcWing 1100. 抓住那头牛 AcWing 1076. 迷宫问题 在求最短路的时候需要存储某个点是由哪个点更新过来的。 #include<iostream> #include<cstring> #define x first #define y second using namespace std; const int N = 1005; typedef pair<int,int&gt
BFS解决最短路问题(详解)
2302_79862386的博客
05-27 1815
说到BFS，想必大家都不陌生，我们在学习二叉树的遍历时所用到的层序遍历其实就是BFS,那么BFS能解决什么样的问题呢？通过本文标题，你也大致能猜到----解决最短路问题，这是一个比较经典的问题，当然,BFS还能解决很多其他问题，本文就着重介绍其中一种---最短路问题。BFS（广度优先搜索）:是一种图形搜索算法，它从根节点开始，逐层地向下扩展搜索。BFS通常用队列来实现，即先进先出的数据结构。这意味着每个节点都将按照它们被发现的顺序进行处理。
10 bfs（flood fill与最短路模型）
m0_63729880的博客
06-17 216
图论bfs
迷宫问题(bfs)
qq_43738331的博客
11-05 1093
给定一个 n×nn×n 的二维数组，如下所示： 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表示可以走的路，只能横着走或竖着走，不能斜着走，要求编程序找出从左上角到右下角的最短路线。 数据保证至少存在一条从左上角走到右下角的路径。 输入格式 第一行包含整数 n。 接下来 nn 行，每行包含 nn 个整数 0 或 1，表示迷宫
[AcWing算法提高课]之搜索（Flood_Fill+最短路模型+多源BFS+最小步数模型）（C++题解）
lihua777的博客
04-14 1233
[AcWing算法提高课]之搜索（Flood_Fill+最短路模型+多源BFS+最小步数模型）（C++题解）
Acwing--1097.池塘计数(Flood Fill)
with_wine的博客
02-04 2944
Flood Fill（泛洪填充）_在？为什么不学习的博客-CSDN博客 Flood Fill（泛洪填充）：从一个起始节点开始，把附近与其连通的节点提取出或填充成不同颜色，直到封闭区域内的所有节点都被处理过为止。 是从一个区域中提取若干个连通的点与其他相邻区域区分开(或分别染成不同颜色)的经典算法。 可以抽象成一个二维矩阵（图片其实就是像素点矩阵），然后从某个点开始向四周扩展，直到无法再扩展为止。 即求连通块问题的算法。 具体实现采用BFS或DFS。 BFS求解：可以求出最短路或者判断两者是否...
Acwing算法提高课—搜索
HENRYyangtuo的博客
11-30 1481
搜索Flood FillAcWing 1097. 池塘计数AcWing 1098. 城堡问题AcWing 1106. 山峰和山谷最短路模型AcWing 1076. 迷宫问题AcWing 188. 武士风度的牛AcWing 1100. 抓住那头牛多源BFSAcWing 173. 矩阵距离最小步数模型AcWing 1107. 魔板双端队列广搜AcWing 175. 电路维修双向广搜AcWing 190. 字串变换A*AcWing 178. 第K短路AcWing 179. 八数码 Flood Fill AcWin
Flood Fill（漫水法）+ 最短路模型
ker的博客
07-06 1130
文章目录 对于一张地图，使用Flood Fill就可以找到最大连通子图，可以使用BFS、DFS来实现，这里使用BFS演示。 可以在线性时间复杂度（O（nm)）内，找到某个点所在的连通块（所有边权重相等） 例题： 城堡问题 图1是一个城堡的地形图。 请你编写一个程序，计算城堡一共有多少房间，最大的房间有多大。 城堡被分割成 m∗n个方格区域，每个方格区域可以有0~4面墙。 注意：墙体厚度忽略不计。 输入格式 第一行包含两个整数 m 和 n，分别表示城堡南北方向的长度和东西方向的长度。 接下来 m 行，
代码随想录算法训练营day30
qq_56445436的博客
09-05 444
【代码】代码随想录算法训练营day30。
树状数组记录
volcan的博客
09-06 674
树状数组（Fenwick Tree）是一种用于维护数组前缀和的数据结构，支持高效的单点更新和区间查询操作。它的查询和更新时间复杂度为Ologn，适用于需要频繁更新和查询的场景。
力扣刷题--1534. 统计好三元组【简单】
m0_75266675的博客
09-04 393
力扣刷题--1534. 统计好三元组【简单】
【算法】单词出现次数和位置统计
Hanbuhuic的博客
09-04 418
编写一个程序，用于统计一个给定单词在一段文本中出现的次数以及第一次出现的位置。如果单词在文本中出现，则输出出现次数和第一次出现的位置（位置从0开始计算）。如果单词没有出现，则输出-1。
深度优先算法，广度优先算法，hill climbing，贪心搜索，A*算法，启发式搜索算法是什么，比起一般搜索法算法有什么区别
最新发布
mimo_mimo的博客
09-10 979
A算法通过维护一个优先队列（通常是最小堆），并根据启发式函数（如g(n) + h(n)，其中g(n)是从起点到当前点的实际距离，h(n)是从当前点到目标点的估计距离）来评估节点的优先级。它从图的某个顶点V0开始，依次访问V0的各个未被访问过的邻接点，然后从这些邻接点出发，再依次访问它们的未被访问过的邻接点，直到图中所有已被访问过的顶点的邻接点都被访问到。它从当前的节点开始，和周围的邻居节点的值进行比较，如果当前节点不是最大的，就用最高的邻居节点来替换当前节点，从而实现向“山峰”的高处攀爬的目的。
【Python 千题 —— 算法篇】寻找两个正序数组的中位数
繁依Fanyi的博客
09-07 1215
合并排序法：易于理解，但时间复杂度较高，适合小规模数据。双指针法：通过双指针合并数组，时间复杂度 O(m + n)，适合中等规模数据。二分查找法：通过二分查找，在较短数组上进行划分，时间复杂度为 O(log(min(m, n)))，是处理大规模数据的最佳选择。对于这种涉及高效搜索和排序的题目，掌握二分查找的应用至关重要。通过本题目，我们不仅能够提升对数组和中位数的理解，还能够学到如何优化时间复杂度，使算法在处理大规模数据时更加高效。
专题一_双指针_算法专题详细总结
2301_80636070的博客
09-06 952
利用双指针，cur=0，dest=-1，只要nums[cur]==0 dest就走两格；否则 dest走一格；但是无论怎么样cur都走一格。直到dest到达结尾处n-1 停止，即 判断dest>=n-1 处 break；
[ C++ ] 一文复习（基础语法，语言特性，STL回顾）
2301_79175236的博客
09-04 1086
C++复习参考文，待完善
[Mdfs] lc131. 分割回文串(子集型枚举+选不选+选不选细节+回文串预处理优化+dp枚举顺序+好题)
Y-puyu 的博客
09-05 998
子集型回溯的拓展题目，看看如何进行问题转换。以及代码优化，很有价值的一道题目哈。for 循环枚举划分位置。
Dijkstra算法与DFS、BFS在图论中的应用
本文将介绍Dijkstra算法以及DFS和BFS在图论中的应用。Dijkstra算法是一种用于寻找图中两点间最短路径的算法，适用于有权重的加权图。而DFS（深度优先搜索）和BFS（广度优先搜索）则是两种基本的图遍历方法，它们在...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值