【AcWing算法提高课】2.1.1BFS中的Flood Fill和最短路模型

已于 2023-01-29 23:02:43 修改
阅读量164 收藏
点赞数
分类专栏： AcWing算法提高课 文章标签： 算法
于 2022-11-20 15:12:50 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_71477690/article/details/126963934
版权

零、BFS的两大模型和使用情景

BFS两大模型：

  1. 最短距离模型 (如基础课“走迷宫”一题)：求方格矩阵中，求以某个点为起点，走到目标终点的最短距离
  2. 最小步数模型 (如基础课“八数码”一题)：把矩阵看成一种状态，求从一种状态到另一种状态的最小变换次数

BFS使用情景：

  1. “求最小”，即BFS第一次搜到目标结果时一定是最小值
  2. 基于迭代，相比于DFS不会爆栈 (算法题中一般默认栈空间为1M)

一、Flood Fill 概述

Flood Fill (洪水填充法)，可在线性时间复杂度内找到某个点所在的连通块。

譬如在一个地形图中，每个小方格有两种高度：“凸起”和“凹进”，为了找到一块相连通的"凹进" (称其为“洼地”)，我们可以先找到任意一块“凹进”，开始注水 (水的总量无限，不会流干)。凭生活经验，水肯定会向四周同是“凹进”的地方蔓延，且不会蔓延至更高的“凸起”。当水不再蔓延时，水所有覆盖的地方既是一块“洼地”。这个过程如下图所示：

在这里插入图片描述
“水”一次次蔓延的过程可以用BFS或者DFS模拟，BFS是“一圈一圈向外蔓延”，DFS则是“沿着一条路线一直流”。由于DFS在深度较大时可能会爆栈，我们一般用BFS模拟蔓延的过程。

二、池塘计数

1097.池塘计数 题目链接

本题要求找到所有相连的“W”块，可以使用Flood Fill方法实现。从前往后寻找第一个“W”块，找到后将池塘数量 + 1 +1 +1 ，并对其“注水”，使得所有与其相连的“W”块均被覆盖。重复以上过程，直到所有“W”块已被覆盖。

代码实现：

#include <cstdio>
#include <algorithm>
#include <cstring>

#define x first
#define y second

using namespace std;

typedef pair <int, int> PII;

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

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

void bfs(int sx, int sy){  //具体的Flood Fill过程，基于BFS实现
    int hh = 0, tt = 0;
    q[0] = {sx, sy};
    st[sx][sy] = 1;
    
    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 >= m) continue;
                if (g[i][j] == '.' || st[i][j]) continue;
                
                q[++ tt] = {i, j};
                st[i][j] = 1;
            }
    }
}

int main(){
    scanf("%d %d", &n, &m);
    for (int i = 0; i < n; i ++) scanf("%s", g[i]);
    
    int cnt = 0;
    for (int i = 0; i < n; i ++)
        for (int j = 0; j < m; j ++)
            if (g[i][j] == 'W' && !st[i][j]){  //找到当前未被覆盖的第一个“W”块
                bfs(i, j);  //对其进行Flood Fill操作
                cnt ++;  //记得将池塘数+1
            }
    printf("%d\n", cnt);
    
    return 0;
}

三、城堡问题

1098.城堡问题 题目链接

本题需要统计房间总数和最大房间的面积，与上题基本相同。注意本题中“墙壁”用二进制方法给出，在判断联通时需要使用位运算。在统计房间面积时，在入队或出队时加一均可，下面给出的代码是在出队时加一。

代码实现：

#include <cstdio>
#include <algorithm>
#include <cstring>

#define x first
#define y second

using namespace std;

typedef pair <int, int> PII;

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

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

int bfs(int sx, int sy){
    int dx[4] = {0, -1, 0, 1}, dy[4] = {-1, 0, 1, 0};  //按照题目顺序，西北东南
    
    int hh = 0, tt = 0;
    int area = 0;
    q[0] = {sx, sy};
    st[sx][sy] = 1;
    
    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;  //提取二进制数的第i位，判断之间是否有墙壁
            
            q[++ tt] = {a, b};
            st[a][b] = 1;
        }
    }
    
    return area;
}

int main(){
    scanf("%d %d", &n, &m);
    for (int i = 0; i < n; i ++)
        for (int j = 0; j < m; j ++)
            scanf("%d", &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 ++;
            }
            
    printf("%d\n%d\n", cnt, area);
    
    return 0;
}

四、山峰和山谷

1106.山峰和山谷 题目链接

本题需要统计山峰和山谷的个数，其中山峰指的是周围没有比它还高的一片区域，山谷是周围没有比它还低的一片区域。在Flood Fill过程中，如果周围的方格高度不同，需要判断它比当前区域高还是低，如果更高，当前区域不会是山峰；如果更低，当前区域不会是山谷。

代码实现：

#include <cstdio>
#include <cstring>
#include <algorithm>

#define x first
#define y second

using namespace std;

typedef pair <int, int> PII;

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

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

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

    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 = 1;
                    else has_lower = 1;
                }
                else if (!st[i][j]){
                    q[++ tt] = {i, j};
                    st[i][j] = 1;
                }
            }
    }
}

int main(){
    scanf("%d", &n);
    for (int i = 0; i < n; i ++)
        for (int j = 0; j < n; j ++)
            scanf("%d", &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 = 0, has_lower = 0;
                bfs(i, j, has_higher, has_lower);
                if (!has_higher) peak ++;
                if (!has_lower) valley ++;  //不能用else，可能既是山峰又是山谷
            }
        }

    printf("%d %d\n", peak, valley);

    return 0;
}

五、迷宫问题

1076.迷宫问题 题目链接

本题在“走迷宫”的基础上要求记录路径。在BFS时，记录每个点是由哪个点走到的，最后逆序输出即可。当然也可反向BFS，将终点和起点互换，记录反向路径后直接正向输出。

代码实现：

#include <cstdio>
#include <cstring>
#include <algorithm>

#define x first
#define y second

using namespace std;

typedef pair <int, int> PII;

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

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

void bfs(int sx, int sy){
    int dx[4] = {-1, 0, 1, 0}, dy[4] = {0, 1, 0, -1};
    
    int hh = 0, tt = 0;
    q[0] = {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 (g[a][b]) continue;
            if (pre[a][b].x != -1) continue;
            
            q[++ tt] = {a, b};
            pre[a][b] = t;
        }
    }
}

int main(){
    scanf("%d", &n);
    for (int i = 0; i < n; i ++)
        for (int j = 0; j < n; j ++)
            scanf("%d", &g[i][j]);
            
    bfs(n - 1, n - 1);  //反向bfs，起点为(n-1,n-1)，终点为(0,0)，这样记录的路径就是正向的
    
    PII end(0, 0);
    
    while (1){
        printf("%d %d\n", end.x, end.y);
        if (end.x == n - 1 && end.y == n - 1) break;
        end = pre[end.x][end.y];
    }
    
    return 0;
}

六、武士风度的牛

188.武士风度的牛 题目链接

普通的BFS问题，马走日。

代码实现：

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

#define x first
#define y second

using namespace std;

typedef pair <int, int> PII;

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

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};  //c++中如果是一维数组且有初始值，可以不用写数组长度
    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 = 0;
    q[0] = {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;
}

七、抓住那头牛

1100.抓住那头牛 题目链接

由于农夫三种移动方式所需要的时间相同，考虑使用BFS。但是如果要使用BFS，问题的搜索空间不能是无限的， 能否框定出一个范围，使得最优解所经过的点一定在这个范围内呢？

可以证明，最优解所经过的点一定在 [ 0 , 2 × 1 0 5 ] [0,2\times 10^5] [0,2×105] 内：
令三种移动方式 X → X − 1 X→X-1 X→X−1， X → X + 1 X→X+1 X→X+1， X → 2 X X→2X X→2X 分别为操作一、二、三

  1. 若某次执行操作一后位置小于 0 0 0，此时执行操作一、三只会离目标点更远，所以在最优解中只会执行操作二；但执行操作二与前面执行的操作一正好抵消，回到原来位置，还不如不执行操作一，故位置不会小于 0 0 0；
  2. 若目标点在当前位置的左边，此时执行操作二、三只会离目标点更远，所以在最优解中只会执行操作一；而目标点 ≤ 1 0 5 \le 10^5 ≤105，故在最优解中会执行操作二、三的点一定 ≤ 2 × 1 0 5 \le 2\times 10^5 ≤2×105 。

在框定了搜索范围后，我们便可使用BFS求出最小步数。

当然我们可以进一步缩小范围至 [ 0 , 1 0 5 ] [0,10^5] [0,105]，因为先执行操作三再执行两次以上的操作一，不如先执行操作一再执行操作三。

代码实现：

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

using namespace std;

const int N = 2e5 + 10;

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

int bfs(){
    memset(dist, -1, sizeof dist);
    dist[n] = 0;
    q[0] = n;

    int hh = 0, tt = 0;

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

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

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

    return -1;  //本题一定有解，可以不用写这句
}

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

    cout << bfs() << endl;

    return 0;
}
匿名博主
关注
专栏目录
卷积神经网络中的物理模型解释与应用(卷积神经网络中的物理模型解释与应用)
AI天才研究院
06-28 6007
本文通过卷积神经网络的物理模型来解释其工作原理，并介绍如何通过物理模型来优化和改进卷积神经网络。通过不断优化网络结构、应用数据增强和实现可解释性的卷积神经网络，可以提高卷积神经网络的性能，以解决实际问题。每一层都会根据当前层的参数值和激活函数的值来计算输入数据的加权和，并将其传递到下一层。(2) 反向传播:反向传播是指根据当前层的输出结果，计算输出层与输入层之间的误差，并将其反向传播到各个层进行调整。本文旨在通过卷积神经网络的物理模型来解释其工作原理，并介绍如何通过物理模型来优化和改进卷积神经网络。
基于Spark MLlib 的推荐系统：实现个性化推荐和协同过滤算法原理
AI天才研究院
06-29 6439
2.2.1 基于用户行为的个性化推荐数据预处理：对用户行为数据进行清洗、转换，生成用户兴趣标签特征工程：从用户行为数据中提取出有用的特征信息模型训练：使用机器学习算法对用户特征进行训练，建立个性化推荐模型推荐服务：根据用户兴趣标签和模型预测，推荐个性化的内容2.2.2 基于协同过滤的个性化推荐数据预处理：对用户行为数据进行清洗、转换，生成用户行为数据特征工程：从用户行为数据中提取出有用的特征信息模型训练：使用机器学习算法对用户行为数据进行训练，建立协同过滤模型。
【经典算法】BFS之Flood Fill
Miiiiiiiiiii的博客
11-09 1236
简述 Flood Fill：字面理解，洪水填充，(大概意思是传播的很快，扩散的广，像水一样四处流动一样)。其实我感觉不就是个BFS嘛，感觉BFS起了个别的名字 大致思想：中间一个点，向四周扩展，每次扩散一圈，下次再一圈…如此下去 我们再想想我们数据结构学的BFS(广度优先遍历)，这不是一回事嘛… 再扩展到题，给人的感觉就是需要加判断，不是说每个点四周的所有点都可以Flood Fill 池塘计数POJ2386 来源： poj2386 题意： 大致的意思是n*m的单元格，"."表示土地，"W"表示水，对于
算法提高课-搜索-最短路模型-AcWing 1076. 迷宫问题：bfs最短路、路径
阿正的梦工坊
03-24 263
刷题
算法提高课-搜索-Flood fill算法-AcWing 1106. 山峰和山谷:flood fill、bfs
阿正的梦工坊
03-24 224
刷题
[AcWing算法提高课]之搜索（Flood_Fill+最短路模型+多源BFS+最小步数模型）（C++题解）
lihua777的博客
04-14 1324
[AcWing算法提高课]之搜索（Flood_Fill+最短路模型+多源BFS+最小步数模型）（C++题解）
算法提高课-搜索-最短路模型-AcWing 188. 武士风度的牛 ：bfs、dist数组记录最小步数
阿正的梦工坊
03-24 225
刷题
算法提高课：2.1.1 BFS中的Flood Fill和最短路模型
Geek
10-12 291
1097. 池塘计数 1098. 城堡问题 1106. 山峰和山谷 1076. 迷宫问题 188. 武士风度的牛 1100. 抓住那头牛
刷题算法提高阶段-搜索1
12-22
这里提到的“2.1.1 FloodFill和最短路.mp4”可能包含了Flood Fill算法与Dijkstra算法或Bellman-Ford算法的讲解，这些算法都是解决最短路径问题的有效工具。 Dijkstra算法适用于有向图或无向图，且边的权重非负。它...
LLM大模型中文开源数据集集锦（三）
素质云笔记
05-16 4243
头两篇在写【】和【然后笔者自己也测试了一把ChatGLM的P-Tuning V2在【】感觉。
【AI人工智能大模型原理讲解】Transformer 神经网络架构实践Network 在不同 NLP 任务中的广泛应用
AI天才研究院
06-29 6067
2.3. 相关技术比较并行化处理：Transformer网络中的多头自注意力机制使得网络可以对输入序列中的多个位置进行并行计算，从而提高模型的训练和预测效率。长依赖处理：由于编码器和解码器都包含多头自注意力机制，网络可以捕捉输入序列中的长距离依赖关系，提高模型的记忆能力。自适应性：Transformer网络可以进行预训练，使得模型在不同的任务中可以自动适应，减少模型的适应和学习过程。计算效率：Transformer网络在计算过程中需要进行多次矩阵乘法，导致其计算效率相对较低。
BFS 算法提高课
m0_53203911的博客
03-19 151
池塘计数 #include<bits/stdc++.h> using namespace std; const int N=1010; char g[N][N]; bool st[N][N]; int n,m; int cnt; int dist[N][N]; int dx[]={0,0,-1,1,1,1,-1,-1},dy[]={-1,1,0,0,1,-1,-1,1}; void bfs(int x,int y){ queue<pair<int,int>>q;
BFS——武士风度的牛
aaa7888210的博客
11-09 151
bfs
C和C ++中的洪水填充算法
culing2941的博客
09-15 3207
洪水填充算法Here you will learn about flood fill algorithm in C and C++. 在这里，您将了解C和C ++中的泛洪填充算法。 Flood Fill is a seed fill algorithm similar to Boundary Fill algorithm but sometimes when it is required to...
C++入门基础知识150—【关于C++ 输入/输出运算符重载】
zhaoylzy的博客
11-16 918
关于【C++输入/输出运算符重载】 一、什么是输入/输出运算符 二、什么是输入输出运算符重载 三、输入输出运算符重载格式 四、输入输出运算符重载参数之间的区别 五、重载提取运算符 >> 和插入运算符
1163：阿克曼(Ackmann)函数
呆萌很的博客
11-12 264
1163：阿克曼(Ackmann)函数
数据库范式、MySQL 架构、算法与树的深入解析
lrh35的博客
11-11 1333
在数据库设计中，范式是一系列规则，用于确保数据的组织和存储具有良好的结构、完整性以及最小化的数据冗余。如果不遵循范式设计，数据可能会以平铺式罗列，仅使用冒号、分号等简单分隔。这种方式存在诸多弊端，例如在数据搜索时极为不便，数据修改也会变得十分棘手。由此，范式的概念应运而生。
【循环测试试题3】小X与数字三角形
最新发布
Lonely_Boos的博客
11-16 97
共n行，第i行包含i个正整数，每个整数占五列。读入一个正整数n，输出一个n行的数字三角形。一行一个正整数n，2
【数据结构】快排之三路划分
2301_79633555的博客
11-13 429
在之前快排是排完序把key放在中间，左边比key值小，右边比key大，跟key相等的值在哪里并没有规定，跟key相等的值可以在左边，也可以在右边。因为假如cur没有遇见比key大的值，right没有--，那么cur与right在相同位置时，并不能确定right所指向的值是否小于key。但是，有些场景下hoae和lomuto（前后指针法）还是适应的不是很好，就是当数组中有大量重复数据时，该场景下性能是有些退化的。cur指向的值与left位置的值进行交换，然后left++，cur++核心思想是把数组中的数据。
2.1.1 网络模型概述
03-25
网络模型是指计算机网络体系结构的一个概念模型，用于描述网络中不同层次及其协议的组织结构和功能，并为开发、实现和维护网络提供标准化的参考。常见的网络模型包括OSI模型和TCP/IP模型。其中OSI模型分为七层，从物理层到应用层，每层都对应不同的协议和功能；而TCP/IP模型较简单，只分为四层，分别是网络接口层、网络层、传输层和应用层。网络模型提供了统一的规范，使得不同厂商开发的网络设备和应用程序能够互相通信和兼容。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值