Flood Fill算法总结

最新推荐文章于 2024-08-15 16:46:15 发布
最新推荐文章于 2024-08-15 16:46:15 发布
阅读量1.1k 收藏 14
点赞数 10
分类专栏： 算法笔记 题目笔记
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/INGg__/article/details/115499273
版权

最近一直跟着y总在刷蓝桥杯的课，借此我来对里面涉及到的Flood Fill算法做一个我目前接触到的所有的flood fill算法的总结

总

首先，这本质上是一个搜索算法。他的作用是对一个图（目前我用到的都是二维数组的图，不是图论的图）的所有的连通块进行操作

它是可以从其中一个点出发，扩展与这个点相邻的所有点

也就是说，给定连通块的所有的点，都可以把这个连通块上所有的点全部搜到

那么我对每一步进行讲解，并对每一个例题给出代码，这里只讲解bfs的写法

int bfs(PII start){
	queue<PII> q; // 宽搜用的队列
	
	q.push(start); // 宽搜入队
	memset(vis, 0, sizeof(vis)); // 对数组进行清空，表示所有点暂时还没有到达过
	vis[start.x][start.y] = 1; // 起点是肯定来过的
	
	int dx[4] = {-1,0,1,0}; // 坐标偏移量数组
    int dy[4] = {0,1,0,-1};
	
	while(!q.empty()){
		PII f = q.front(); // 取出队头
		q.pop(); // 弹出队头元素
		
		for(int i = 0; i < 4; i++){ // 对现在得到的坐标的上下左右四个方向的偏移的各个位置的状况进行查看及操作
			int x = f.x + dx[i]; // 各个方向上的坐标
			int y = f.y + dy[i]; 
			
			if(x < 0 || x >= w || y < 0 || y >= h) continue; // 防止越界
			if(mapp[x][y] == '#') continue; // 如果是障碍物就退出
			if(vis[x][y]) continue; // 遍历过就退出，防止二次统计
            
			vis[x][y] = 1; // 我这时候已经来过这个点了
			q.push({x, y});	 // 压入队列，后期再看这个点的其他点
		}
	}
	
	return *; // 可能要返回值
}

题

下面给出四个题：

AC1101. 献给阿尔吉侬的花束

AC1113. 红与黑

AC1096. 地牢大师

AC1233. 全球变暖

AC1101

基本上就是上面的简单不扩展应用，这里用了dis数组同时记录距离和访问

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

using namespace std;

typedef pair<int,int> PII;

const int N = 210;

int T;
char mapp[N][N];
int dis[N][N];
int r, c;

int bfs(PII start, PII end){
    memset(dis, -1, sizeof(dis));
    queue<PII> q;
    
    dis[start.first][start.second] = 0;
    
    q.push(start);
    int dx[4] = {-1,0,1,0};
    int dy[4] = {0,1,0,-1};
    while(!q.empty()){
        PII f = q.front();
        q.pop();
        for(int i = 0; i < 4; i++){
            int x = f.first + dx[i];
            int y = f.second + dy[i];
            
            if(x < 0 || x >= r || y < 0 || y >= c) continue;
            if(mapp[x][y] == '#') continue;
            if(dis[x][y] != -1) continue;
            
            dis[x][y] = dis[f.first][f.second] + 1;
            if(mapp[x][y] == 'E') return dis[x][y];
            
            q.push({x,y});
        }
    }
    
    return -1;
}

int main(){
    cin >> T;
    while(T--){
        cin >> r >> c;
        for(int i = 0; i < r; i++){
            scanf("%s",mapp[i]);
        }
        
        PII start, end;
        
        for(int i = 0; i < r; i++){
            for(int j = 0; j < c; j++){
                if(mapp[i][j] == 'S') start = {i,j};
                if(mapp[i][j] == 'E') end = {i, j};
            }
        }
        
        int d = bfs(start, end);
        if(d == -1) cout << "oop!\n";
        else cout << d << "\n";
    }
    return 0;
}

AC1113

这个题也是简单扩展，但是要注意它要求的答案是黑色的瓷砖，只加入黑色的瓷砖的坐标，这样才能求好这个连通块的相关值

也要注意，起始位置就是在黑色瓷砖上的

#include <iostream>
#include <cstdio>
#include <algorithm>
#include <cstring>
#include <cmath>
#include <map>
#include <vector>
#include <set>
#include <queue>
#include <stack>
#include <sstream>
#define ll long long
#define re return
#define x first
#define y second

using namespace std;

typedef pair<int, int> PII;

int w, h;
char mapp[30][30];
bool vis[30][30];

int bfs(PII start){
	int cnt = 1;
	queue<PII> q;
	
	q.push(start);
	memset(vis, 0, sizeof(vis));
	vis[start.x][start.y] = 1;
	
	int dx[4] = {-1,0,1,0};
    int dy[4] = {0,1,0,-1};
	
	while(!q.empty()){
		PII f = q.front();
		q.pop();
		
		for(int i = 0; i < 4; i++){
			int x = f.x + dx[i];
			int y = f.y + dy[i];
			
			if(x < 0 || x >= w || y < 0 || y >= h) continue;
			if(mapp[x][y] == '#') continue;
			if(vis[x][y]) continue;
			if(mapp[x][y] == '.'){
				cnt++;
				vis[x][y] = 1;
				q.push({x, y});	
			}
		}
	}
	
	return cnt;
}

int main(){
	while(cin >> h >> w && w && h){
		for(int i = 0; i < w; i++){
			scanf("%s",mapp[i]);
		}
		PII start;
		for(int i = 0; i < w; i++){
			for(int j = 0; j < h; j++){
				if(mapp[i][j] == '@'){
					start = {i, j};
					break;
				}
				// cout << mapp[i][j] << " ";
			}
			// cout << endl;
		}
		// cout << start.x << " " << start.y << endl;
		cout << bfs(start) << endl;
	}
	return 0;
}

AC1096

这个题也是简单的扩展；是唯一的连通块的题只不过上升为了三维而已

#include <iostream>
#include <cstdio>
#include <algorithm>
#include <cstring>
#include <cmath>
#include <map>
#include <vector>
#include <set>
#include <queue>
#include <stack>
#include <sstream>
#define ll long long
#define re return

using namespace std;

typedef pair<int, int> PII;

struct node{
	int x;
	int y;
	int z;
};

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

char mapp[110][110][110];
int l, r, c; // L,R,C  分别表示地牢层数，以及每一层地牢的行数和列数。
int dis[110][110][110];

int bfs(node start, node end){
	memset(dis, -1, sizeof(dis));
	
	dis[start.x][start.y][start.z] = 0;
	
	queue<node> q;
	
	q.push(start);
	
	while(!q.empty()){
		node f = q.front();
		q.pop();
		for(int i = 0; i < 6; i++){
			int x = f.x + dx[i];
			int y = f.y + dy[i];
			int z = f.z + dz[i];
			
			if(x < 0 || x >= l || y < 0 || y >= r || z < 0 || z >= c) continue;
			if(mapp[x][y][z] == '#') continue;
			if(dis[x][y][z] != -1) continue;
			
			dis[x][y][z] = dis[f.x][f.y][f.z] + 1;
			
			
			if(end.x == x && end.y == y && end.z == z) return dis[x][y][z]; // 到达终点就可以返回距离了
			
			
			
			q.push({x,y,z});
			
		}
	}
	return -1;
}

int work(){
	cin >> l >> r >> c;
	if(!l && !r && !c) return 0;
	
	for(int i = 0; i < l; i++){
		for(int j = 0; j < r; j++){
			scanf("%s",mapp[i][j]);
		}
	}
	
	node start, end;
	
	for(int i = 0; i < l; i++){
		for(int j = 0; j < r; j++){
			for(int k = 0; k < c; k++){
				if(mapp[i][j][k] == 'S') start = {i, j, k};
				if(mapp[i][j][k] == 'E') end = {i, j, k};
			}
		}
	}
	
	int d = bfs(start, end);
	if(d == -1) cout << "Trapped!" << endl;
	else printf("Escaped in %d minute(s).\n", d	);
	return 1;
}

int main(){
	while(work() != 0);
	return 0;
}

AC1233

这个题就不一样了，他是有多个连通块；在每个连通块下，需要对每个连通块进行操作

然后找到这个连通块中每个可能将会成海洋的块，然后与在这个连通块中所有曾经是陆地的个数进行对比，如果相等，那么之后就肯定会被完全淹没

#include <iostream>
#include <cstdio>
#include <algorithm>
#include <cstring>
#include <cmath>
#include <map>
#include <vector>
#include <set>
#include <queue>
#include <stack>
#include <sstream>
#define ll long long
#define re return
#define x first
#define y second

using namespace std;

typedef pair<int, int> PII;

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

int n;

char mapp[1000 + 10][1000 + 10];
bool vis[1000 + 10][1000 + 10];

int bfs(int xx, int yy){
	queue<PII> q;
	
	q.push({xx, yy});
	vis[xx][yy] = 1;
	
	int earth = 0;
	int sea = 0;
	
	while(!q.empty()){
		PII f = q.front()
		q.pop();
		
		int t = 0; //看这个点的四个方向的情况！注意，要完全理解flood fill算法中每一步具体是干什么的
		earth++;
		
		for(int i = 0; i < 4; i++){
			int x = f.x + dx[i];
			int y = f.y + dy[i];
			
			if(x < 0 || x >= n || y < 0 || y >= n) continue;
			if(vis[x][y] == 1) continue;
			if(mapp[x][y] == '.'){
				t = 1;
				continue;
			}

			vis[x][y] = 1;
			
			q.push({x, y});
		}
		if(t) sea ++;
	}
	
	return sea == earth;
}

int main(){
	cin >> n;
	for(int i = 0; i < n; i++){
		scanf("%s", mapp[i]);
	}
	
	int cnt = 0; //看连通块的数量
	
	for(int i = 0; i < n; i++){
		for(int j = 0; j < n; j++){
			if(vis[i][j] == 0 && mapp[i][j] == '#'){
				int x = bfs(i, j);
				// cout << x << endl;
				if(x) cnt++;
			}
		}
	}
	
	// for(int i = 0; i < )
	cout << cnt;
	return 0;
}
INGg__
关注
专栏目录
【经典算法】BFS之Flood Fill
Miiiiiiiiiii的博客
11-09 1181
简述 Flood Fill：字面理解，洪水填充，(大概意思是传播的很快，扩散的广，像水一样四处流动一样)。其实我感觉不就是个BFS嘛，感觉BFS起了个别的名字 大致思想：中间一个点，向四周扩展，每次扩散一圈，下次再一圈…如此下去 我们再想想我们数据结构学的BFS(广度优先遍历)，这不是一回事嘛… 再扩展到题，给人的感觉就是需要加判断，不是说每个点四周的所有点都可以Flood Fill 池塘计数POJ2386 来源： poj2386 题意： 大致的意思是n*m的单元格，"."表示土地，"W"表示水，对于
图像处理------泛洪填充算法(Flood Fill Algorithm) 油漆桶功能
weixin_34235371的博客
07-24 1704
泛洪填充算法(Flood Fill Algorithm) 泛洪填充算法又称洪水填充算法是在很多图形绘制软件中常用的填充算法，最熟悉不过就是 windows paint的油漆桶功能。算法的原理很简单，就是从一个点开始附近像素点，填充成新 的颜色，直到封闭区域内的所有像素点都被填充新颜色为止。泛红填充实现最常见有四邻域 像素填充法，八邻域像素填充法，基于扫描...
洪水填充算法（Flood Fill）和广度优先搜索算法（Breadth-First Search, BFS）的共同点与不同点
最新发布
CylMK的博客
08-15 514
洪水填充算法（Flood Fill）定义：洪水填充是一种用于确定图像中与给定起点像素相连的区域的算法。它通常用于图像处理中的区域填充，比如在绘图软件中填充一个封闭区域。目的：主要用于图像处理、区域填充、分区识别等场景。广度优先搜索（BFS）定义：BFS是一种图搜索算法，用于从一个给定的起始节点开始，按层次遍历图中所有节点。它使用队列结构来逐层扩展搜索范围。目的：主要用于图论中查找最短路径、连通性分析、图遍历等场景。
池塘计数(Flood Fill)
qq_43738331的博客
11-04 750
农夫约翰有一片 N∗MN∗M 的矩形土地。 最近，由于降雨的原因，部分土地被水淹没了。 现在用一个字符矩阵来表示他的土地。 每个单元格内，如果包含雨水，则用”W”表示，如果不含雨水，则用”.”表示。 现在，约翰想知道他的土地中形成了多少片池塘。 每组相连的积水单元格集合可以看作是一片池塘。 每个单元格视为与其上、下、左、右、左上、右上、左下、右下八个邻近单元格相连。 请你输出共有多少片池塘，即矩阵中共有多少片相连的”W”块。 输入格式 第一行包含两个整数 NN 和 MM。 接下来 NN 行，每行包含 MM
flood fill算法
多看多听多总结
02-13 493
flood fill算法实现有三种形式 1、depth first search 2、breadth first search 3、breadth first scan 基本思想是找到还没有分配component的结点，并且计算哪个componetn包含此结点。 深度优先搜索算法是通过当前结点的所有邻接结点查找一步，对于还没有分配component的结点，赋值相应的component，然...
FloodFill算法
兔清风的博客
04-02 5492
1.   http://blog.csdn.net/u012763794/article/details/51113362 2、维基百科中文 https://zh.wikipedia.org/wiki/Flood_fill 3、wiki英文 https://en.wikipedia.org/wiki/Flood_fill
Flood fill 算法
Ant
05-01 759
http://en.wikipedia.org/wiki/Flood_fill#Stack-based_recursive_implementation_.28Four-way.29
带你学习Flood Fill算法与最短路模型
「 虚幻私塾」
01-21 1193
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：无法求解最短路问题；可能会爆栈（递
the-flood:Flood Fill算法的Clojure库
05-31
用于 Flood Fill 算法的 Clojure 库。 ，只做了很小的改动。 安装Arkifact 将以下条目添加到project.clj文件的:dependencies向量： [ ] ( ) 淹没地球 user=> ( require '[the-flood.core :refer [flood-fill]]) ...
Flood_Fill算法
05-25
Flood Fill 算法 Flood Fill 算法是一种常用的图形算法，用于寻找无向图中的极大连通子图。该算法可以用深度优先搜索、广度优先搜索或广度优先扫描来实现。其实现方式是寻找到一个未被标记的结点，对它标记后扩展，...
Flood Fill算法
06-08
Flood Fill算法是一种常用的图像处理算法，可以用来填充连通区域。在迷宫问题中，Flood Fill算法可以用来寻找从起点到终点的路径。 Flood Fill算法的基本思想是：从某个起点开始，不断向四周扩散，直到扩散到不能...
魔棒算法(Floodfill)
10-24
自己写的一个种子填充算法,又叫洪水填充,设置了阈值，简单的实现了Photoshop中的魔棒算法，与大家分享一下！
iOS flood fill 算法
01-03
在Objective-C中实现Flood Fill算法，可以为游戏开发、图像编辑应用等提供便利。 Flood Fill算法通常有几种不同的实现方式，如四连通、八连通和十四连通等，其中四连通只考虑上下左右相邻的像素，八连通则包括对角...
常见算法之Flood Fill算法
weixin_46207366的博客
02-08 4708
常见算法之Flood Fill算法 算法介绍 基本作用：寻找连通块 基本方法：BFS 适用题目：需要找出分类块的题目 顾名思义，Flood Fill算法就是像洪水泛滥一样去寻找周围符合条件的区域，采用BFS可以完成先从自身最近的点寻找随后逐步扩展。 代码思路 设置函数bfs 传入参数坐标，创建队列，初始位置压入 将形参坐标改变，并标记已经访问（防止重复） 循环直到队列空 将队头元素取出 判断改变后的坐标是不是满足要求（范围，标记状态，属于连通块等） 若满足状态，压入队列，将状态重置 例题 池塘计数
算法沉淀——FloodFill 算法（leetcode真题剖析）
立志做一个高产且细节博主
02-23 1846
Flood Fill（泛洪填充）算法是一种图像处理的基本算法，用于填充连通区域。该算法通常从一个种子点开始，沿着种子点的相邻像素进行填充，直到遇到边界或者其他指定的条件为止。Flood Fill 算法的主要应用是在图像编辑软件中实现填充操作，以及在计算机图形学、计算机视觉等领域中进行区域填充。
Flood Fill 算法
sblsf的博客
09-02 640
Flood Fill算法，又称洪水填充，泛洪算法其思想是：从一个种子点开始，将与其连通（可达且颜色相同/相近）的点全部染上另外一种颜色，直到所有可达节点都被染色为止。
Flood-Fill算法
Shao_yihao的博客
07-05 344
Flood-Fill算法主要用于网格图。 从起点出发，分别枚举四个方向的邻格，判断是否为陆地，过程宛若洪水漫延。
FloodFill 算法
m0_37286282的博客
01-07 399
输入数据会构成一个无向图，包含图的顶点个数和边数。你需要输出经过 FloodFill 算法染色后的节点，要求将每个节点按染色结果分类。其中，和之前学习的一样，输入的节点从编号为 00 开始，染色的结果由 11 开始递增。 输入格式 输入的第一行为两个整数 nn 和 mm（1 \leq n,m \leq 1001≤n,m≤100），分别表示图中顶点个数和边数。接下来共有 mm 行，格式为
floodfill算法
weixin_48262500的博客
03-02 1199
#在图像处理中就是给定一个种子点作为起始点，向附近相邻的像素点扩散， # 把颜色相同或者相近的所有点都找出来，并填充上新的颜色 # 这些点形成一个连通的区域。 漫水填充算法可以用来标记或者分离图像的一部分 #漫水填充算法实现最常见有四邻域像素填充法， # 八邻域像素填充法，基于扫描线的填充方法 import cv2 from matplotlib import image import numpy as np import os.path as osp import os impo.
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值