第二章 搜索（Flood Fill，最短路模型，多源BFS）

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

文章目录

池塘计数（flood fill）

问题描述

在这里插入图片描述
在这里插入图片描述

解题思路

flood fill模板题，掌握基本的bfs就可以上手做了，具体思路和解释见代码中注释

AC代码

#include <iostream>
#include <cstring>
#include <algorithm>
#include <queue>
#define x first
#define y second
using namespace std;
typedef pair<int, int> PII;

const int N = 1005;

char w[N][N];  //读入池塘的字符串
bool st[N][N]; // st数组用于判重，表示该点已经走过
int res = 0, n, m;
//八个方向的方向偏移量
int dx[8] = {-1, -1, -1, 0, 1, 1, 1, 0};
int dy[8] = {-1, 0, 1, 1, 1, 0, -1, -1};
queue<PII> q;

void bfs(int x, int y) //每次BFS会搜索一块连通区域
{
    q.push({x, y});
    st[x][y] = true;
    while (q.size())
    {
        int xx = q.front().x, yy = q.front().y;
        q.pop();
        for (int i = 0; i < 8; i++)
            for (int j = 0; j < 8; j++)
            {
                int a = dx[i] + xx, b = dy[i] + yy;
                if (a < 1 || b < 1 || a > n || b > m)
                    continue; //若越界，则不符合要求，返回
                if (st[a][b])
                    continue; //如果已经搜索过了，则不符要求，返回
                if (w[a][b] == '.')
                    continue;    //如果是海洋，则不符要求，返回
                q.push({a, b});  //都满足要求了，则将该点入队
                st[a][b] = true; //同时标记为已经搜索过了
            }
    }
}

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

    for (int i = 1; i <= n; i++)
        for (int j = 1; j <= m; j++)
        {
            if (w[i][j] == 'W' && !st[i][j])
                bfs(i, j), res++; //每搜索一次连通区域，答案数量+1
        }

    cout << res << endl;
    return 0;
}

城堡问题（flood fill）

问题描述

在这里插入图片描述
在这里插入图片描述

解题思路

也是经典的flood fill算法问题，只不过稍微增加了一层包装，关键在于每个数字的意义是什么，具体解释见下图
图片转自
在这里插入图片描述

AC代码

#include <iostream>
#include <cstring>
#include <algorithm>
#include <queue>
#define x first
#define y second
using namespace std;
typedef pair<int, int> PII;

const int N = 1005;

int w[N][N];
bool st[N][N];
int res = 0, n, m;
int dx[4] = {0, -1, 0, 1}, dy[4] = {-1, 0, 1, 0};
queue<PII> q;

int bfs(int x, int y)
{
    int cnt = 0;
    q.push({x, y});
    st[x][y] = true;
    while (q.size())
    {
        int xx = q.front().x, yy = q.front().y;
        q.pop();
        cnt++;
        for (int i = 0; i < 4; i++)
        {
            int a = dx[i] + xx, b = dy[i] + yy;
            if (a < 1 || b < 1 || a > n || b > m)
                continue; //判断是否出界
            if (st[a][b])
                continue; //已经被搜索过了
            if (w[xx][yy] >> i & 1)
                continue; //此处是关键：判断当前点的周围的点是否是墙，如果是墙，则返回
            q.push({a, b});
            st[a][b] = true;
        }
    }
    return cnt;
}

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

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

山峰和山谷（flood fill）

问题描述

在这里插入图片描述
在这里插入图片描述

解题思路

还是flood fill的基本模型，问题转换为，搜索连通区域是值为相等的区域，同时，需要判断连通块中周围的点是否比他高还是比他低由此判断出它是山峰还是山谷

AC代码

#include <iostream>
#include <cstring>
#include <algorithm>
#include <queue>
#define x first
#define y second
using namespace std;
const int N = 1010;
typedef pair<int, int> PII;

int n;
int w[N][N];
bool st[N][N];
int dx[8] = {-1, -1, -1, 0, 1, 1, 1, 0};
int dy[8] = {-1, 0, 1, 1, 1, 0, -1, -1};

queue<PII> q;

//相比其他flood fill的题目，本题就是多了两个参数，用于判断是一个连通块周围是否存在比他高的点或者低的点
void bfs(int xx, int yy, bool &high, bool &low)
{
    q.push({xx, yy});
    st[xx][yy] = true;
    while (q.size())
    {
        int x = q.front().x, y = q.front().y;
        q.pop();
        for (int i = 0; i < 8; i++)
        {
            int a = x + dx[i], b = y + dy[i];

            if (a < 1 || b < 1 || a > n || b > n)
                continue;
            if (w[a][b] != w[x][y])
            {
                if (w[a][b] > w[x][y])
                    high = true;
                else
                    low = true;
            }
            else if (!st[a][b])
            {
                q.push({a, b});
                st[a][b] = true;
            }
        }
    }
}

int main()
{
    cin >> n;
    for (int i = 1; i <= n; i++)
        for (int j = 1; j <= n; j++)
        {
            cin >> w[i][j];
        }

    int peak = 0, valley = 0;
    for (int i = 1; i <= n; i++)
        for (int j = 1; j <= n; j++)
        {
            if (!st[i][j])
            {
                bool high = false, low = false;
                bfs(i, j, high, low);
                if (!high)
                    peak++;
                if (!low)
                    valley++;
            }
        }
    cout << peak << " " << valley;
    return 0;
}

迷宫问题（最短路模型）

问题描述

在这里插入图片描述
在这里插入图片描述

解题思路

相比于前面几题，本题的特点是需要输出最短路的路径，因此，在bfs的过程中，需要采用pre数组记录每一个状态的前驱状态，最后按顺序输出即可。因为是要按正序输出，所以我们从终点向起点做bfs，这样最后按序输出的pre数组即为答案。

AC代码

#include <iostream>
#include <cstring>
#include <algorithm>
#include <queue>
#define x first
#define y second
using namespace std;
typedef pair<int, int> PII;
const int N = 1010;

queue<PII> q;
int n;
int w[N][N];
PII pre[N][N]; //相比于前面几题，pre数组用于记录一个状态的前驱状态
int dx[4] = {-1, 0, 1, 0}, dy[4] = {0, 1, 0, -1};

void bfs()
{
    memset(pre, -1, sizeof pre);
    pre[n - 1][n - 1] = {0, 0}; //从终点向起点做bfs
    q.push({n - 1, n - 1});
    while (q.size())
    {
        int x = q.front().x, y = q.front().y;
        PII temp = q.front();
        q.pop();
        for (int i = 0; i < 4; i++)
        {
            int a = x + dx[i], b = y + dy[i];
            if (a < 0 || a >= n || b < 0 || b >= n)
                continue;
            if (pre[a][b].x != -1)
                continue;
            if (w[a][b])
                continue;

            q.push({a, b});
            pre[a][b] = temp; //记录前驱
        }
    }
}

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

    bfs();

    PII end(0, 0);

    while (true)
    {
        //在输出时，从起点开始输出，然后不停地寻找前驱，直到找到（n-1，n-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;
}

武士风度的牛（最短路模型）

问题描述

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

解题思路

和前面的题相比，本题只是多了一个dist数组，用于记录从起点到达当前位置的距离，其余的都是广搜的模板

AC代码

#include <iostream>
#include <cstring>
#include <algorithm>
#include <queue>
#define x first
#define y second
using namespace std;
typedef pair<int, int> PII;
const int N = 200;

int n, m;
char g[N][N];
int dist[N][N];//dist数组表示从起点到当前点的最短距离
int gx, gy, ox, oy;
int dx[8] = {-2, -1, 1, 2, 2, 1, -1, -2};
int dy[8] = {1, 2, 2, 1, -1, -2, -2, -1};
int res = 0;
queue<PII> q;

void bfs(int ox, int oy)
{
    memset(dist, -1, sizeof dist);
    q.push({ox, oy});
    dist[ox][oy] = 0;

    while (q.size())
    {
        int x = q.front().x, y = q.front().y;
        q.pop();
        int a, b;
        for (int i = 0; i < 8; i++)
        {
            a = x + dx[i], b = y + dy[i];
            if (a < 1 || b < 1 || a > n || b > m)
                continue;
            if (dist[a][b] != -1)
                continue;
            if (g[a][b] == '*')
                continue;
            dist[a][b] = dist[x][y] + 1;
            q.push({a, b});
        }
    }
}

int main()
{
    cin >> m >> n;
    for (int i = 1; i <= n; i++)
        for (int j = 1; j <= m; j++)
        {
            cin >> g[i][j];
            if (g[i][j] == 'K')
                ox = i, oy = j;
            if (g[i][j] == 'H')
                gx = i, gy = j;
        }
    bfs(ox, oy);

    cout << dist[gx][gy];
    return 0;
}

抓住那头牛（最短路模型）

问题描述

在这里插入图片描述

解题思路

一维线段上的bfs，会出现三个方向的状态偏移。
需要注意的是每个点并非只能遍历一次，具体见注释\

AC代码

#include <iostream>
#include <cstring>
#include <algorithm>
#include <queue>
using namespace std;
const int N = 2e5 + 5; //这里在定义最大N的时候一定要注意bfs会搜索到两倍空间，所以需要开两倍

queue<int> q;
int d[N];
int n, k;

void bfs(int m)
{
    q.push(m);
    while (q.size())
    {
        int x = q.front();
        q.pop();
        int c[3] = {-1, 1, x}; //方向偏移量
        for (int i = 0; i < 3; i++)
        {
            int a = x + c[i];
            //若当前点<0时，此时，只能+1往前走，会做无用功
            //若当前点>2k时，说明肯定是经过*2来到此状态的，那么也是相当于无用功
            if (a <= 0 || a > k * 2)
                continue;
            if (d[a] > d[x] + 1 || d[a] == -1) //每个点并非只能经过一次，每次经过一个点时，要么没有经过，要么可以被更新到更小
            {
                d[a] = d[x] + 1;
                q.push(a);
            }
        }
        if (x == k)
            return;
    }
}

int main()
{
    cin >> n >> k;
    memset(d, -1, sizeof d);
    d[n] = 0;
    bfs(n);
    if (n > k) //若当前点在目标点右侧，则最优方案就是不停往前走
    {
        cout << n - k;
        return 0;
    }
    cout << d[k] << endl;
    return 0;
}

矩阵距离（多源BFS）

问题描述

在这里插入图片描述

解题思路

容易将题目抽象为求出矩阵上的每个点到达所有值为1的点的距离的最小值。我们可以将所有值为1的点初始化为起点，易得最小值为0，同时我们虚拟出一个源点，源点到达各起点的距离为-1。题目进一步抽象为求出虚拟源点到达各个点的最短距离，此时就转换为了普通的最短路模型了
在这里插入图片描述

AC代码

#include <iostream>
#include <cstring>
#include <algorithm>
#include <queue>
#define x first
#define y second
using namespace std;
typedef pair<int, int> PII;
const int N = 1010;

int n, m;
char w[N][N];
int dist[N][N]; // dist数组代表的是矩阵上的每个点到达所有1这个点的距离中的最小值
int st[N][N];
queue<PII> q;
int dx[4] = {-1, 0, 1, 0}, dy[4] = {0, 1, 0, -1};

void bfs()
{
    //和前面几题相比，只需要将所有起点初始加入到队列中
    for (int i = 1; i <= n; i++)
        for (int j = 1; j <= m; j++)
        {
            if (w[i][j] == '1')
            {
                dist[i][j] = 0;
                st[i][j] = true;
                q.push({i, j});
            }
        }

    while (q.size())
    {
        int x = q.front().x, y = q.front().y;
        q.pop();
        for (int i = 0; i < 4; i++)
        {
            int a = x + dx[i], b = y + dy[i];
            if (st[a][b])
                continue;
            if (a < 1 || b < 1 || a > n || b > m)
                continue;

            dist[a][b] = dist[x][y] + 1;
            q.push({a, b});
            st[a][b] = true;
        }
    }
}

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

    bfs();

    for (int i = 1; i <= n; i++)
    {
        for (int j = 1; j <= m; j++)
            cout << dist[i][j] << " ";
        cout << endl;
    }
    return 0;
}
chase__young
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
带你学习Flood Fill算法与最短路模型
「 虚幻私塾」
01-21 846
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：池塘计数【Flood Fill模板】
qq_42581685的博客
02-13 172
常用于在线性时间内寻找连通块。大致思想如下：在一大块土地上，有若干高地（灰色的格子），现在往土地上的某个格子倒洪水，水只会在低处蔓延（白色格子），无法覆盖高地。水在每一个时间单位只会向周围（上下左右，左上、左下、右上、右下）蔓延一格。时间1：时间2：时间3：每个时间单位，相当于宽搜的一层搜索。一开始队列里只有开始倒水的格子，然后将周围格子加到队列，再将把新加进来格子周围的格子加进队列。当没有新格子进来时，这部分就是连通块。注意覆盖后要对格子进行标记，防止重复覆盖。
[FloodFill] aw1106. 山峰和山谷(bfs+FloodFill+模板题)
Y-puyu 的博客
06-12 113
文章目录1. 题目来源2. 题目解析 1. 题目来源 链接：1106. 山峰和山谷 2. 题目解析 FloodFill 第三种，求连通块，重点在于判断连通块属性。 此题为 8 连通，高度相同的为同一个连通块，高度不同的则为两个山脉。 则可以进行高度判断，如果连通块中不存在任意一个边界比它高、低，那这个连通块中的山脉就是山峰、山谷。在 bfs 的过程中加以判断即可。 这样就能根据题意判断出连通块的属性了。 注意在整个高度均一致的时候，它既是山峰，也是山谷，代码中注释部分为易错点。 像 FloodFill 这类
AcWing 1402 星空之夜（Flood Fill 算法）
qq_45728527的博客
01-30 108
链接: link. 首先根据题意，我们应该先找出所有连通块，这里我们用到的是Flood Fill 算法。 然后我们要判断两连通块形状是否相同（通过旋转或对称可以使连通块变到重合）。这里我们采用哈希存储下不同形状的连通块。我们要保证形状形同的连通块映射到同一个数，且尽量避免冲突。这里我们采用两两之间的欧几里得距离作为哈希函数。 Flood Fill 模板 BFS模板 void bfs(int a,int b) { queue<PAIR> q; st[a][b] = true;
BFS Flood Fill（连通性） 例题
weixin_45724872的博客
10-19 250
题面 城堡问题 Flood Fill介绍 Flood Fill应用的题型主要在于求连通块的题目； Code #include <iostream> #include <cstdio> #include <algorithm> #include <utility> #include <queue> using namespace std; typedef long long ll; const int N = 1e2 + 10; int
10 bfs（flood fill与最短路模型）
m0_63729880的博客
06-17 196
图论bfs
acwing算法提高之搜索--BFS中的Flood Fill和最短路模型
YMWM_的博客
02-24 200
acwing算法提高之搜索--BFS中的Flood Fill和最短路模型
Flood-fill:ZX Spectrum的洪水填充算法
05-09
洪水填充 优化填充算法以最小化内存（Z80 / ZX Spectrum） 参与竞争Z5编程挑战赛＃5的规模 最小尺寸填充 171字节+ 10字节堆栈 右手洪水算法 LOOPING_MODE = false; set DIRECTION; ...TEST_1: // Drzime se prave ...
Flood-inundation-risk-analysis.rar_SWAT_ae_flood fill _淹没_淹没分析
07-14
VS2005+AE9.2 洪水淹没 实现洪水面的自动演示，简单易懂。AE二次开发。
xuqiufenxi.rar_flood routing_xuqiufenxi_模型_洪水_演进
09-24
洪水演进模型洪水演进模型洪水演进模型洪水演进模型
the-flood:Flood Fill算法的Clojure库
05-31
用于 Flood Fill 算法的 Clojure 库。 ，只做了很小的改动。 安装Arkifact 将以下条目添加到project.clj文件的:dependencies向量： [ ] ( ) 淹没地球 user=> ( require '[the-flood.core :refer [flood-fill]]) ...
Bcast_Flood.rar_2 hop_Ad移动模型_bcast_flood_flood broadcast_广播 算法
09-23
在NS-2环境中实现了移动Ad Hoc的两种广播算法:Flood和Bcast。里面本来有个test目录，包含了很多节点移动模型文件，由于太大了，因此就没上传。
【C++】——Stack与Queue（含优先队列（详细解读）
m0_74092462的博客
06-09 1005
优先队列是一种容器适配器，根据严格的弱排序标准，它的第一个元素总是它所包含的元素中最大的。stack是一种容器适配器，专门用在具有后进先出操作的上下文环境中，其删除只能从容器的一端进行元素的插入与提取操作。 队列是一种容器适配器，专门用于在FIFO上下文(先进先出)中操作，其中从容器一端插入元素，另一端提取元素。
C++——计算不同的非空子串个数
我发布的博客，快来抄答案吧
06-09 143
BCSP-X 11题 C++代码详解
【c++进阶(三)】STL之vector的介绍和使用
最新发布
weixin_62196764的博客
06-15 684
1.vector表示的是可变序列大小的容器2、vector就像数组一样，也采用的连续空间来存储元素，这也意味着可以采用下标对vector的元素进行访问。3、vector与普通数组不同的是，vector的大小是可以动态改变的。4、当vector需要重新分配大小时，其做法是，分配一个新的数组，然后将全部元素移到这个数组当中，并释放原来的数组空间。---这就表明原来指向该位置的迭代器已经失效了，所以在插入和删除数据的时候要返回一个合法的迭代器的位置。
c++|unordered系列关联式容器(unordered_set、unordered_map介绍使用+哈希结构)
weixin_68201503的博客
06-09 752
1.unordered_set与set一样元素key与value是一一对应的，且是唯一的,set中的key不能在容器中修改(元素总是const)，但是可以插入和删除,且元素是去重的。2.unordered_set与set不一样的是，其底层是由数组实现，数组存储的是，且节点值的顺序没有按照特定的顺序排序，为了能在常数范围内找到可以所对应的key，unordered_set将相同哈希值的键值对放在相同的桶中(比较抽象，待后续分析)。
【2024最新华为OD-C/D卷试题汇总】[支持在线评测] CPU算力分配(100分) - 三语言AC题解(Python/Java/Cpp)
清隆学长的博客
06-11 315
### 问题描述 K小姐是某公司运营部门的主管,最近她需要对公司的两组服务器进行算力分配。每组服务器有多个算力不同的 $CPU$,其中 $A$ 组第 $i$ 个 $CPU$ 的运算能力为 $A[i]$,而 $B$ 组第 $i$ 个 $CPU$ 的运算能力为 $B[i]$。一组服务器的总算力是各 $CPU$ 的算力之和。 为了让两组服务器的算力相等,K小姐允许从每组各选出一个 $CPU$ 进行一次交换。她希望从 $A$ 组服务器中选出算力尽可能小的 $CPU$ 来交换,你能帮她计算出应该选择哪两个 $CP
STL——Stacks容器
qq_74811378的博客
06-11 289
top() 函数返回对栈顶元素的引用. 举例,如下代码显现和清空一个堆栈。所有的这些操作可以被用于堆栈. 相等指堆栈有相同的元素并有着相同的顺序。size() 函数返当前堆栈中的元素数目。如当前堆栈为空，empty() 函数 返回。值压栈，使其成为栈顶的第一个元素。pop() 函数移除堆栈中最顶层元素。push() 函数将。
flood fill
10-20
Flood Fill算法是一种对连通区域进行着色的算法，它从一个起点开始，将相邻的区域都标记上同样的颜色。它通常被用来填充或者着色图像中的封闭区域，比如说在绘图软件中使用它来填充闭合的多边形区域。Flood Fill算法包括四个基本步骤：选择一个起点，标记起点颜色，将与起点相邻且颜色相同的区域标记上同样的颜色，重复第三步直到没有相邻的区域可以被标记。 本文提到的Flood Fill算法实现有两个版本，一个是使用BFS（广度优先搜索）实现，另一个是使用DFS（深度优先搜索）实现。在实际应用中，可以根据具体情况选择合适的算法实现。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

chase__young

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值