第二章 搜索 No.1BFS之Flood Fill与最短路模型

最新推荐文章于 2024-06-27 17:17:34 发布
最新推荐文章于 2024-06-27 17:17:34 发布
阅读量86 收藏
点赞数
分类专栏： AcWing算法提高课 课程记录 文章标签： 宽度优先 深度优先 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_61432764/article/details/132322618
版权

文章目录

Flood Fill算法

可以在线性时间复杂度内，找到某个点所在的连通块
想象一个矩阵，有洼地和高地，选择一个洼地，向外扩展新的洼地，遇到高地不扩展。可以用bfs实现也能用dfs实现

bfs的题型大概有两种：一种是矩阵中的最短距离，一种是矩阵变换的最小步数
bfs的两个特点：1. 基于迭代，不会爆栈 2. 最短路

1097. 池塘计数

1097. 池塘计数 - AcWing题库
image.png

经典的Flood Fill，对整张图进行bfs即可

#include <iostream>
using namespace std;

typedef pair<int, int> PII;
const int N = 1010, M = N * N;
char g[N][N];
PII q[M];
int n, m;

void bfs(int x, int y)
{
    int hh = 0, tt = -1;
    q[ ++ tt ] = { x, y };
    g[x][y] = '.';
    while (tt >= hh)
    {
        auto t = q[hh ++ ];
        int tx = t.first, ty = t.second;
        for (int i = tx - 1; i <= tx + 1; ++ i )
            for (int j = ty - 1; j <= ty + 1; ++ j )
            {
            	if (i < 0 || i >= n || j < 0 || j >= m) continue;
                if (i == tx && j == ty) continue;
				if (g[i][j] == '.') continue;
				q[ ++ tt ] = { i, j };
				g[i][j] = '.';
            }
    }
}

int main()
{
    scanf("%d%d", &n, &m);
    for (int i = 0; i < n; ++ i ) scanf("%s", g[i]);
    
    int res = 0;
    for (int i = 0; i < n; ++ i )
        for (int j = 0; j < m; ++ j )
            if (g[i][j] == 'W')
            {
                res ++ ;
                bfs(i, j);
            }
            
    printf("%d\n", res);
    return 0;
}

debug：每次bfs时，hh和tt都要重置，所以不能设置为全局变量，并且还要赋初值

1098. 城堡问题

1098. 城堡问题 - AcWing题库
image.png

这题比较特殊，与上题不同障碍物（墙）不是格子，而是格子的边界
这里只要在bfs扩展时，根据输入的数据判断扩展方向的边界上是否有墙，若没有墙再往外扩展即可

#include <iostream>
using namespace std;

typedef pair<int, int> PII;
const int N = 55, M = N * N;
int g[N][N];
PII q[M]; bool st[N][N];
int n, m;
int dx[4] = { 0, -1, 0, 1 }, dy[4] = { -1, 0, 1, 0 };

int bfs(int x, int y)
{
    int hh = 0, tt = -1, sz = 0;
    q[ ++ tt ] = { x, y };
    st[x][y] = true;
    while (tt >= hh )
    {
        sz ++ ;
        auto t = q[hh ++ ];
        int tx = t.first, ty = t.second;
        for (int i = 0; i < 4; ++ i )
        {
            int nx = tx + dx[i], ny = ty + dy[i];
            if (nx < 0 || nx >= n || ny < 0 || ny >= m) continue;
            if (st[nx][ny]) continue;
            if ((g[tx][ty] >> i) & 1) continue; // 有墙
			q[ ++ tt ] = { nx, ny };
			st[nx][ny] = true;
        }
    }
    return sz;
}

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, res = 0;
    for (int i = 0; i < n; ++ i )
        for (int j = 0; j < m; ++ j )
            if (!st[i][j])
            {
                cnt ++ ;
                res = max(res, bfs(i, j));
            }
            
    printf("%d\n%d\n", cnt, res);
    return 0;
}

debug：每个房间的面积等于bfs迭代的次数，所以每次迭代都要sz ++ ，若只在扩展时sz ++ ，那么sz会少1

1106. 山峰和山谷

1106. 山峰和山谷 - AcWing题库
image.png

所有高度相同的格子为一个连通块，bfs时判断连通块的相邻格子与连通块的高度h关系
若存在高于h的格子，higher为true，若存在低于h的格子，lower为true
最后（反向）判断如果higher为false，表示周围格子都比h矮，所以连通块为山峰
如果lower为false，表示走位格子都比h高，那么连通块为山谷
如果两者都为true，说明周围既有高于h的格子又有低于h的格子，那么该连通块既不是山峰又不是山谷
若两者都为false，说明整个矩阵为一个连通块，那么连通块即是山峰又是山谷

#include <iostream>
using namespace std;

const int N = 1010, M = N * N;
typedef pair<int, int> PII;
PII q[M]; bool st[N][N];
int g[N][N];
int n; 

void bfs(int x, int y, bool &higher, bool &lower)
{
    int tt = -1, hh = 0;
    q[ ++ tt ] = { x, y };
    st[x][y] = true;
    while (tt >= hh )
    {
        auto t = q[hh ++ ];
        int tx = t.first, ty = t.second;
        for (int i = tx - 1; i <= tx + 1; ++ i )
            for (int j = ty - 1; j <= ty + 1; ++ j )
	        {
		        if (i < 0 || i >= n || j < 0 || j >= n) continue;
                if (i == tx && j == ty) continue;
				if (g[i][j] > g[tx][ty]) higher = true;
				else if (g[i][j] < g[tx][ty]) lower = true;
				else if (!st[i][j])
				{
					q[ ++ tt ] = { i, j };
					st[i][j] = true;
				}
            }
    }
}

int main()
{
    scanf("%d", &n);
    for (int i = 0; i < n; ++ i )
        for (int j = 0; j < n; ++ j )
            scanf("%d", &g[i][j]);
            
    int t = 0, v  = 0;
    for (int i = 0; i < n; ++ i )
        for (int j = 0; j < n; ++ j )
            if (!st[i][j])
            {
                bool higher = false, lower = false;
                bfs(i, j, higher, lower);
                if (!higher) t ++ ;
                if (!lower) v ++ ;
            }
            
    printf("%d %d\n", t, v);
    return 0;
}

debug：st数组标记已经访问过的格子，并不是标记和当前bfs的连通块的高度相同的格子
所以以下bfs是错误的

    while (tt >= hh )
    {
        auto t = q[hh ++ ];
        int tx = t.first, ty = t.second;
        for (int i = tx - 1; i <= tx + 1; ++ i )
            for (int j = ty - 1; j <= ty + 1; ++ j )
            {
	            if (i < 0 || i >= n || j < 0 || j >= n) continue;
                if (st[i][j]) continue;
                if (i >= 0 && i < n && j >= 0 && j < n)
				if (g[i][j] > g[tx][ty]) higher = true;
				else if (g[i][j] < g[tx][ty]) lower = true;
				else 
				{
					q[ ++ tt ] = { i, j };
					st[i][j] = true;
				}
            }
    }

扩展时，不能只扩展为标记过的点。因为不仅要扩展高度相同的格子，还需要将当前格子与边界进行比较，若边界的高度为当前格子不同，而边界格子被标记过，那么就会错过比较

最短路模型

1076. 迷宫问题

1076. 迷宫问题 - AcWing题库
image.png

单源最短路，且权值相同，使用bfs即可
每次扩展时维护last数组，记录点由哪个点扩展而来，最后dfs输出last即可

#include <iostream>
using namespace std;

typedef pair<int, int> PII;
const int N = 1010, M = N * N;
int g[N][N];
PII last[N][N], q[M];
int n; bool st[N][N];
int dx[4] = { 0, 0, 1, -1 }, dy[4] = { 1, -1, 0, 0 };

void bfs(int x, int y)
{
    int tt = -1, hh = 0;
    st[x][y] = true;
    q[ ++ tt ] = { x, y };
    while (tt >= hh)
    {
        auto t = q[hh ++ ];
        int tx = t.first, ty = t.second;
        for (int i = 0; i < 4; ++ i )
        {
            int nx = tx + dx[i], ny = ty + dy[i];
            if (nx < 0 || nx >= n || ny < 0 || ny >= n) continue;
            if (g[nx][ny] == 1 || st[nx][ny]) continue;
        
            q[ ++ tt ] = { nx, ny };
            st[nx][ny] = true;
            last[nx][ny] = t;
        }
    }
}

void dfs(int x, int y)
{
    if (x == 0 && y == 0)
    {
        printf("%d %d\n", x, y);
        return;
    }
    dfs(last[x][y].first, last[x][y].second);
    printf("%d %d\n", x, y);
}

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(0, 0);
                
    dfs(n - 1, n - 1);
    return 0;
}

除了后序遍历路径，递归输出，还可以反向求路径：求终点到起点的最短路径，保存每个点的上一个点，最后正序输出

#include <iostream>
using namespace std;

typedef pair<int, int> PII;
const int N = 1010, M = N * N;
int g[N][N];
PII last[N][N], q[M];
int n; bool st[N][N];
int dx[4] = { 0, 0, 1, -1 }, dy[4] = { 1, -1, 0, 0 };

void bfs(int x, int y)
{
    int tt = -1, hh = 0;
    st[x][y] = true;
    q[ ++ tt ] = { x, y };
    while (tt >= hh)
    {
        auto t = q[hh ++ ];
        int tx = t.first, ty = t.second;
        for (int i = 0; i < 4; ++ i )
        {
            int nx = tx + dx[i], ny = ty + dy[i];
            if (nx < 0 || nx >= n || ny < 0 || ny >= n) continue;
            if (g[nx][ny] == 1 || st[nx][ny]) continue;
        
            q[ ++ tt ] = { nx, ny };
            st[nx][ny] = true;
            last[nx][ny] = 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);
        
    PII t = { 0, 0 };        
    while (true)
    {
        printf("%d %d\n", t.first, t.second);
        if (t.first == n - 1 && t.second == n - 1) break;
        t = last[t.first][t.second];
    }
    return 0;
}

188. 武士风度的牛

188. 武士风度的牛 - AcWing题库
image.png

一般bfs的扩展都是4个或8个方向，虽然这题的扩展是8方向，但是扩展的位置与平时不同，所以需要特别小心地处理坐标

#include <iostream>
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]; bool st[N][N];
int dis[N][N];
int dx[8] = { -2, -2, -1, 1, 2, 2, 1, -1 }, dy[8] = { -1, 1, 2, 2, 1, -1, -2, -2 };

int bfs(int x, int y)
{
    int tt = -1, hh = 0;
    q[ ++ tt ] = { x, y };
    st[x][y] = true;
    while (tt >= hh)
    {
        auto t = q[hh ++ ];
        int tx = t.first, ty = t.second;
        for (int i = 0; i < 8; ++ i )
        {
            int nx = tx + dx[i], ny = ty + dy[i];
            if (nx < 0 || nx >= n || ny < 0 || ny >= m) continue;
            if (st[nx][ny] || g[nx][ny] == '*') continue;
            dis[nx][ny] = dis[tx][ty] + 1;
            if (g[nx][ny] == 'H') return dis[nx][ny];
            q[ ++ tt ] = { nx, ny };
            st[nx][ny] = true;
        }
    }
    return 0;
}

int main()
{
    scanf("%d%d", &m, &n);
    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] == 'K')
            {
                 printf("%d\n", bfs(i, j));
                 break;
            }
    
    return 0;
}

debug：艹，输入的n和m是反着的，先m再n

1100. 抓住那头牛

1100. 抓住那头牛 - AcWing题库
image.png

将不同的移动方式看成递达不同点的一条边，用bfs从源点向外扩展，第一次递达终点的距离一定是最短的

#include <iostream>
using namespace std;

const int N = 1e5 + 10;
bool st[N];
int q[N], hh, tt = -1;
int dis[N];
int n, k;

int bfs()
{
    q[ ++ tt ] = n;
    st[n] = true;
    while (tt >= hh )
    {
        int t = q[hh ++ ];
        if (t == k) return dis[k];
        if (!st[t - 1] && t - 1 >= 0 && t < N)
        {
            st[t - 1] = true;
            dis[t - 1] = dis[t] + 1;
            q[ ++ tt ] = t - 1;
        }
        if (!st[t + 1] && t + 1 >= 0 && t + 1 < N)
        {
            st[t + 1] = true;
            dis[t + 1] = dis[t] + 1;
            q[ ++ tt ] = t + 1;
        }
        if (!st[t * 2] && t * 2 >= 0 && t * 2 < N)
        {
            st[t * 2] = true;
            dis[t * 2] = dis[t] + 1;
            q[ ++ tt ]= t * 2;
        }
    }
    return -1;
}

int main()
{
    scanf("%d%d", &n, &k);
    printf("%d\n", bfs());
    return 0;
}
.SacaJawea
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
10 bfs（flood fill与最短路模型）
m0_63729880的博客
06-17 203
图论bfs
acwing算法提高之搜索--BFS中的Flood Fill和最短路模型
YMWM_的博客
02-24 204
acwing算法提高之搜索--BFS中的Flood Fill和最短路模型
AcWing.算法提高课_BFS中的Flood Fill和最短路模型
wazsja的博客
08-02 327
Flood Fill 模型与最短路模型
算法提高之搜索：BFS中的Flood Fill和最短路模型
qq_37448336的博客
02-10 561
目录0、基础课中的bfs1、Flood Fill1.1、池塘计数(统计连通块的数量)1.2、城堡问题（统计连通块的数量和最大值）1.3、山峰和山谷（判断连通块的类型）2、最短路模型2.1、迷宫问题（记录路径）2.2、武士风度的牛（日字形走法）2.3、抓住那头牛 0、基础课中的bfs 1、Flood Fill 1M/开一层所消耗的内存 就可以得到总共开多少层。 1.1、池塘计数(统计连通块的数量) #include <cstring> #include <iostrea
BFS 找最短路.cpp
07-23
题解：Bfs找最短路径（正解，绝对正确）这是c++中一道题的题解
BFS搜索 迷宫.cpp
10-13
BFS搜索案例——走出迷宫。 广度优先搜索BFS（Breadth First Search）也称为宽度优先搜索，它是一种先生成的结点先扩展的策略。
人工智能：第1章 搜索问题.ppt
06-17
《人工智能：第1章 搜索问题》主要探讨的是在人工智能领域中如何利用计算机解决搜索问题，特别是通过模拟人类思维过程来寻找最优化解决方案的方法。这一章涵盖了多种搜索策略和技术，包括盲目搜索、启发式搜索以及...
人工智能：第二章 状态空间搜索问题.pdf
07-11
《人工智能：第二章 状态空间搜索问题》章节深入探讨了人工智能在解决复杂非结构化问题时采用的状态空间搜索策略。这一章主要分为五个部分：搜索问题、状态空间表示法、无信息搜索、启发式搜索以及本章小结。 首先...
BFS广度优先搜索视频演示.mp4
10-25
宽度优先搜索算法（又称广度优先搜索）是最简便的图的搜索算法之一，这一算法也是很多重要的图的算法的原型。Dijkstra单源最短路径算法和Prim最小生成树算法都采用了和宽度优先搜索类似的思想。其别名又叫BFS，属于...
岛屿个数（dfs)
初九·潜龙勿用的博客
04-07 5113
小蓝得到了一副大小为M×N的格子地图，可以将其视作一个只包含字符0（代表海水）和1（代表陆地）的二维数组，地图之外可以视作全部是海水，每个岛屿由在上/下/左/右四个方向上相邻的1相连接而形成。x0​y0​x1​y1​...xk−1​yk−1​，其中 (x,y) 是由xi​yi​通过上/下/左/右移动一次得来的 (0≤i≤k−1)，此时这 k 个格子就构成了一个 “环”。
常微分方程算法之编程示例六-解一阶方程组（龙格-库塔法）
欢迎各位大佬光临“寒舍”！请多多指点，共同进步！
06-27 311
主要对本专栏介绍的常微分方程差分格式进行算例补充。
算法常见问题
u012374012的专栏
06-24 943
是一种二分类模型，它的基本模型是定义在特征空间上的间隔最大的线性分类器，间隔最大使它有别于感知机。线性可分SVM当训练数据线性可分时，通过最大化硬间隔（hard margin）可以学习得到一个线性分类器，即硬间隔SVM。线性SVM当训练数据不能线性可分但是近似线性可分时，通过最大化软间隔（soft margin）也可以学习到一个线性分类器，即软间隔SVM。非线性SVM当训练数据线性不可分时，通过使用核技巧（kernel trick）和最大化软间隔，可以学习到一个非线性SVM。
力扣503
最新发布
weixin_63680330的博客
06-27 249
给定一个循环数组nums的下一个元素是nums[0]），返回 nums中每个元素的。数字x的是按数组遍历顺序，这个数字之后的第一个比它更大的数，这意味着你应该循环地搜索它的下一个更大的数。如果不存在，则输出-1。[2,-1,2]第一个 1 的下一个更大的数是 2；数字 2 找不到下一个更大的数；第二个 1 的下一个最大的数需要循环搜索，结果也是 2。
560. 和为 K 的子数组
侯仕奇的博客
06-26 217
给你一个整数数组 nums 和一个整数 k ，请你统计并返回 该数组中和为 k 的子数组的个数。子数组是数组中元素的连续非空序列。整体时间复杂度优化为 O(n。
状态压缩动态规划（State Compression DP）算法详解
TheJustice_的博客
06-26 1432
状态压缩DP的核心思想是利用位运算来表示和操作状态。可以用一个整数的二进制位来表示一个状态集合中的元素是否存在。例如，对于一个有 n 个元素的集合，可以用一个 n 位的二进制数表示其子集，其中第 i 位为1表示该子集包含第 i 个元素，为0则表示不包含。状态压缩DP是一种高效解决某些组合优化问题的技术，通过使用位运算来表示和操作状态，大大减少了状态空间的大小和复杂度。在理解和应用状态压缩DP时，关键在于正确表示和转移状态。希望通过本文的讲解和例题分析，能帮助读者更好地理解和应用这一算法。
素数筛(算法篇)
hellmorning的博客
06-24 722
讲述算法中的素数筛
【算法介绍】开集识别算法 OpenMax
Glass_Gun的博客
06-25 446
OpenMax是一种用于深度学习模型的，它能够在模型的输出中区分已知类别和未知类别。该算法的核心思想是利用深度神经网络的倒数第二层（全连接层）的激活向量，通过构建每个类别的平均激活向量（MAV）和距离集（D），进而使用极值理论（EVT）来拟合这些激活向量的分布，从而计算出每个测试样本属于已知类别的概率。如果一个测试样本的概率低于某个阈值，则它被认为是未知类别。
算法训练营第六十九天 | 并查集理论基础、寻找存在的路径、冗余连接、冗余连接II
qq_63149342的博客
06-24 270
​。
flood fill
10-20
Flood Fill算法是一种对连通区域进行着色...本文提到的Flood Fill算法实现有两个版本，一个是使用BFS（广度优先搜索）实现，另一个是使用DFS（深度优先搜索）实现。在实际应用中，可以根据具体情况选择合适的算法实现。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值