FloodFill

最新推荐文章于 2024-01-25 21:27:33 发布
最新推荐文章于 2024-01-25 21:27:33 发布
阅读量171 收藏
点赞数
分类专栏： 综合算法篇 文章标签： 深度优先 算法 bfs
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/rngwgzzs/article/details/134631842
版权

"绝境之中才窥见，Winner，Winner" 

FloodFill算法简介:

        floodfill又翻译成漫水填充。我们可以将下面的矩阵理解为一片具有一定高度的坡地，此时突发洪水，洪水会将高度<0的地方填满。        

        话句话来说，FloodFill算法是为了找出那些具有相同性质的区域。那我们现在就来看看一些经典的使用floodfill算法的题目。

图像渲染

(1) 题目解析        

                这类题目的代码部分，都是将模拟的过程转化成代码。

(2) 算法代码

dfs:

class Solution {
public:
    int m,n;
    int prev;
    int dx[4] = {0,0,1,-1};
    int dy[4] = {1,-1,0,0};
    vector<vector<int>> floodFill(vector<vector<int>>& image, int sr, int sc, int color) {
        m = image.size(),n = image[0].size();
        if(image[sr][sc] == color) return image;
        prev = image[sr][sc];
        dfs(image,sr,sc,color);
        return image;
    }

    void dfs(vector<vector<int>>& image, int i,int j,int newcolor)
    {
        // 从这一点出发，每一个方向去 递归相邻节点
        image[i][j] = newcolor;
        for(int k=0;k<4;++k)
        {
            int x=i+dx[k],y = j+dy[k];
            // 满足 要渲染更改的值 
            if(x>=0 && x<m && y>=0 && y<n && image[x][y] == prev)
            {
                dfs(image,x,y,newcolor);
            }
        }
    }
};

 bfs:       

class Solution {
public:
    typedef pair<int,int> PII;
    int m,n;
    int prev;
    int dx[4] = {0,0,1,-1};
    int dy[4] = {1,-1,0,0};
    vector<vector<int>> floodFill(vector<vector<int>>& image, int sr, int sc, int color) {
        m = image.size(),n = image[0].size();
        if(image[sr][sc] == color) return image;
        // 当前位置会被修改为newcolor 这里是保存需要被渲染的值
        prev = image[sr][sc];
        bfs(image,sr,sc,color);
        return image;
    }

    void bfs(vector<vector<int>>& image, int i,int j,int newcolor)
    {
        queue<PII> que;
        image[i][j] = newcolor;
        que.push({i,j});
        while(que.size())
        {
            // 取出已经被渲染的位置，并将它的相邻位置，满足条件的 插入进队列
            auto [a,b] = que.front();
            que.pop();

            for(int k=0;k<4;++k)
            {
                int x=a+dx[k],y=b+dy[k];
                if(x>=0 && x<m && y>=0 && y<n && image[x][y] == prev)
                {
                    image[x][y] = newcolor;
                    que.push({x,y});
                }
            }
        }
    }
};

岛屿数量

(1) 题目解析        

注: 进行bfs或dfs时需要注意，防止统计已经遍历过的位置。我们有两种解决方法，其一就是对原数组内部的值进行修改，区别于目标条件，其二就是创建一个新的布尔数组，标记每一个遍历过的点。

(2) 算法代码

dfs:        

class Solution {
public:
    int m,n;
    bool vis[301][301];
    int dx[4] = {0,0,1,-1};
    int dy[4] = {1,-1,0,0};
    int numIslands(vector<vector<char>>& grid) {
        m = grid.size(),n = grid[0].size();
        int count = 0;
        for(int i=0;i<m;++i)
            for(int j=0;j<n;++j)
            {
                // 遍历到岛屿进行一次dfs 并且这个位置没有被访问过
                if(grid[i][j] == '1' && !vis[i][j]) 
                {
                    count++;
                    vis[i][j] = true; // 标记
                    dfs(grid,i,j);
                }
            }
        
        return count;
    }

    void dfs(vector<vector<char>>& grid,int i,int j)
    {
        // 这里的dfs 只需将与(i,j) 相连的岛屿统计即可
        for(int k=0;k<4;++k)
        {
            int x=i+dx[k],y=j+dy[k];
            if(x>=0 && x<m && y>=0 && y<n && grid[x][y] == '1' && !vis[x][y])
            {
                vis[x][y] = true;
                dfs(grid,x,y);
            }
        }
    }
};

bfs:

    class Solution {
    public:
        int m,n;
        bool vis[301][301];
        int dx[4] = {0,0,1,-1};
        int dy[4] = {1,-1,0,0};
        int numIslands(vector<vector<char>>& grid) {
            m = grid.size(),n = grid[0].size();
            int count = 0;
            for(int i=0;i<m;++i)
                for(int j=0;j<n;++j)
                {
                    // 遍历到岛屿进行一次dfs 并且这个位置没有被访问过
                    if(grid[i][j] == '1' && !vis[i][j]) 
                    {
                        count++;
                        vis[i][j] = true; // 标记
                        bfs(grid,i,j);
                    }
                }
            
            return count;
        }

        void bfs(vector<vector<char>>& grid,int i,int j)
        {
            // 这里的bfs 只需将与(i,j) 相连的岛屿统计即可
            // bfs通常需要借助队列来实现
            queue<pair<int,int>> que;
            que.push({i,j});
            while(que.size())
            {
                auto [a,b] = que.front();
                que.pop();
                for(int k=0;k<4;++k)
                {
                    int x=a+dx[k],y=b+dy[k];
                    if(x>=0 && x<m && y>=0 && y<n && grid[x][y] == '1' && !vis[x][y])
                    {
                        vis[x][y] = true;
                        que.push({x,y});
                    }
                }
            }
        }
    };

岛屿的最大面积

(1) 题目解析        

        这道题和上个题目十分类似，只不过这道题目的结果是求这些岛屿的最大面积，所以，我们需要对相连岛屿数量进行统计，并最终返回一个最大值。

(2) 算法代码

dfs:

class Solution {
public:
    int m,n;
    bool vis[301][301];
    int dx[4] = {0,0,1,-1};
    int dy[4] = {1,-1,0,0};
    int ret,count;
    int maxAreaOfIsland(vector<vector<int>>& grid) {
        m = grid.size(),n = grid[0].size(),ret = 0;
        for(int i=0;i<m;++i)
            for(int j=0;j<n;++j)
            {
                // 遍历到岛屿进行一次dfs 并且这个位置没有被访问过
                if(grid[i][j] == 1 && !vis[i][j]) 
                {
                    count = 0;
                    dfs(grid,i,j);
                    ret = max(ret,count);
                }
            }
        return ret;
    }

    void dfs(vector<vector<int>>& grid,int i,int j)
    {
        vis[i][j] = true;
        count++;
        for(int k=0;k<4;++k)
        {
            int x=i+dx[k],y=j+dy[k];
            if(x>=0 && x<m && y>=0 && y<n && grid[x][y] == 1 && !vis[x][y])
            { 
                dfs(grid,x,y);
            }
        }
    }
};

bfs:

class Solution {
public:
    int m,n;
    bool vis[301][301];
    int dx[4] = {0,0,1,-1};
    int dy[4] = {1,-1,0,0};
    int ret,count;
    int maxAreaOfIsland(vector<vector<int>>& grid) {
        m = grid.size(),n = grid[0].size(),ret = 0;
        for(int i=0;i<m;++i)
            for(int j=0;j<n;++j)
            {
                // 遍历到岛屿进行一次dfs 并且这个位置没有被访问过
                if(grid[i][j] == 1 && !vis[i][j]) 
                {
                    count = 0;
                    vis[i][j] = true; // 标记
                    bfs(grid,i,j);
                    ret = max(ret,count);
                }
            }
        return ret;
    }

    void bfs(vector<vector<int>>& grid,int i,int j)
    {
        // 这里的bfs 只需将与(i,j) 相连的岛屿统计即可
        // bfs通常需要借助队列来实现
        queue<pair<int,int>> que;
        que.push({i,j});
        count++;
        while(que.size())
        {
            auto [a,b] = que.front();
            que.pop();
            for(int k=0;k<4;++k)
            {
                int x=a+dx[k],y=b+dy[k];
                if(x>=0 && x<m && y>=0 && y<n && grid[x][y] == 1 && !vis[x][y])
                {
                    count++;
                    vis[x][y] = true;
                    que.push({x,y});
                }
            }
        }
    }
};

被围绕的区域

(1) 题目解析        

        但其实，我们发现这两个dfs本质是做同样的事情，但却因为判断边界，我们需要写两份不同的dfs，这是蛮麻烦的事情。我们换个思路，直接用一个dfs将边界的'O'，进行过滤，并填上不相关的字符，再将整个数组遍历，遇到‘O’改为‘X’，遇到这个不相关的字符，改为'O'。

(2) 算法代码

dfs:

class Solution {
public:
    int m,n;
    bool vis[201][201];
    int dx[4] = {0,0,-1,1};
    int dy[4] = {1,-1,0,0};
    void solve(vector<vector<char>>& board) {
        m = board.size(),n = board[0].size();
        // 处理第一行和最后一行
        for(int j=0;j<n;++j)
        {
            if(board[0][j] == 'O') dfs(board,0,j);
            if(board[m-1][j] == 'O') dfs(board,m-1,j);
        }

        // 第一列 最后一列
        for(int i=0;i<m;++i)
        {
            if(board[i][0] == 'O') dfs(board,i,0);
            if(board[i][n-1] == 'O') dfs(board,i,n-1);
        }

        for(int i=0;i<m;++i)
            for(int j=0;j<n;++j)
            {
                if(board[i][j] == '.') board[i][j] = 'O';
                else if(board[i][j] == 'O') board[i][j] = 'X';
            }
    }

    void dfs(vector<vector<char>>& board,int i,int j)
    {
        board[i][j] = '.';
        for(int k=0;k<4;++k)
        {
            int x=i+dx[k],y=j+dy[k];
            if(x>=0 && x<m && y>=0 && y<n && board[x][y] == 'O')
            {
                dfs(board,x,y);
            }
        }
    }
};

bfs:        

class Solution {
public:
    int m,n;
    bool vis[201][201];
    int dx[4] = {0,0,-1,1};
    int dy[4] = {1,-1,0,0};
    void solve(vector<vector<char>>& board) {
        m = board.size(),n = board[0].size();
        // 处理第一行和最后一行
        for(int j=0;j<n;++j)
        {
            if(board[0][j] == 'O') bfs(board,0,j);
            if(board[m-1][j] == 'O') bfs(board,m-1,j);
        }

        // 第一列 最后一列
        for(int i=0;i<m;++i)
        {
            if(board[i][0] == 'O') bfs(board,i,0);
            if(board[i][n-1] == 'O') bfs(board,i,n-1);
        }

        for(int i=0;i<m;++i)
            for(int j=0;j<n;++j)
            {
                if(board[i][j] == '.') board[i][j] = 'O';
                else if(board[i][j] == 'O') board[i][j] = 'X';
            }
    }

    void bfs(vector<vector<char>>& board,int i,int j)
    {
        board[i][j] = '.';
        queue<pair<int,int>> que;
        que.push({i,j});
        while(que.size())
        {
            auto [a,b] = que.front();
            que.pop();
            for(int k=0;k<4;++k)
            {
                int x=a+dx[k],y=b+dy[k];
                if(x>=0 && x<m && y>=0 && y<n && board[x][y] == 'O')
                {
                    board[x][y] = '.';
                    que.push({x,y});
                }
            }
        }
    }
};

扫雷

(1) 题目解析        

        经典的扫雷游戏，至于玩法也就不过多解释。该题目考察的地方就在于，点击一个点之后，从这个 点开始进行对相邻领域的展开，我们可以采用dfs或bfs完成。

        当挖出的位置是一个雷，将这个位置标记成‘X’，游戏结束。当挖出的一个地方是空位置，你需要首先去相邻区域查找是否有雷，如果没有发现雷，则标记为'B'，否则就需要将搜查到的雷的个数，标记在该位置处。

(2) 算法代码

dfs:

class Solution {
public:
    int m,n;
    bool vis[51][51];
    // 扫雷位置有八个位置需要被展开
    int dx[8] = {0,0,-1,1,-1,1,-1,1};
    int dy[8] = {1,-1,0,0,1,-1,-1,1};
    vector<vector<char>> updateBoard(vector<vector<char>>& board, vector<int>& click) {
        m = board.size(),n = board[0].size();
        int i = click[0],j = click[1];
        if(board[i][j] == 'M')
            board[i][j] = 'X';
        else
            dfs(board,i,j);
        return board;
    }

    void dfs(vector<vector<char>>& board,int i,int j)
    {
        int count = 0;
        // 统计雷的数量
        for(int k=0;k<8;++k)
        {
            int x=i+dx[k],y=j+dy[k];
            if(x>=0 && x<m && y>=0 && y<n && board[x][y] == 'M') count++;
        }

        if(count){
            board[i][j] = count + '0';
        }
        else{
            board[i][j] = 'B';
            for(int k=0;k<8;++k)
            {
                int x=i+dx[k],y=j+dy[k];
                if(x>=0 && x<m && y>=0 && y<n && board[x][y] == 'E') dfs(board,x,y);
            }
        }
    }
};

bfs:        

class Solution {
public:
    int m,n;
    bool vis[51][51];
    // 扫雷位置有八个位置需要被展开
    int dx[8] = {0,0,-1,1,-1,1,-1,1};
    int dy[8] = {1,-1,0,0,1,-1,-1,1};
    vector<vector<char>> updateBoard(vector<vector<char>>& board, vector<int>& click) {
        m = board.size(),n = board[0].size();
        int i = click[0],j = click[1];
        if(board[i][j] == 'M')
            board[i][j] = 'X';
        else
            bfs(board,i,j);
        return board;
    }

    void bfs(vector<vector<char>>& board,int i,int j)
    {
        queue<pair<int,int>> que;
        que.push({i,j});
        vis[i][j] = true;

        while(que.size())
        {
            auto [a,b] = que.front();
            que.pop();
            
            int count = 0;
            // 统计雷的数量
            for(int k=0;k<8;++k)
            {
                int x=a+dx[k],y=b+dy[k];
                if(x>=0 && x<m && y>=0 && y<n && board[x][y] == 'M') count++;
            }

            if(count){
                board[a][b] = count + '0';
            }
            else{
                board[a][b] = 'B';
                for(int k=0;k<8;++k)
                {
                    int x=a+dx[k],y=b+dy[k];
                    if(x>=0 && x<m && y>=0 && y<n && board[x][y] == 'E')
                    {
                        // 这里改为'B' 避免被其他点统计到 队列中去
                        // 也可以使用 vis[x][y] = ture; 进行标记 不被统计 ！！！
                        board[x][y] = 'B'; 
                        que.push({x,y});
                    }
                }
            }
        }
    }
};

本篇到此结束，感谢你的阅读。

祝你好运，向阳而生~

WGzZsyu
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
FloodFill算法详解及应用
wolfGuiDao的博客
03-07 7691
FloodFill算法详解及应用 啥是 FloodFill 算法呢， 最直接的一个应用就是「颜色填充」，就是 Windows 绘画本中 那个小油漆桶的标志，可以把一块被圈起来的区域全部染色。 这种算法思想还在许多其他地方有应用。比如说扫雷游戏，有时候你点一个方格， 会一下子展开一片区域，这个展开过程，就是 FloodFill 算法实现的。 类似的，像消消乐这类游戏，相同方块积累到一定数量，就全...
floodFill.cpp
06-21
此程序有不少按键功能，用鼠标对窗口的图形进行多次单击就可以实现类似PhotoShop中魔棒的效果*/ 按键功能：1：切换彩色/灰度模式 2：显示/隐藏掩膜窗口 3：恢复原始图像 4：使用空范围的漫水填充 5：使用渐变、固定范围的漫水填充 6：使用渐变、浮动范围的漫水填充 7：操作标志符的低八位使用4位的连接模式 8：操作标志符的低八位使用8位的连接模式
泛洪填充 floodfill demo
06-17
在做表情识别项目过程中遇到脸分区的问题，本以为可以用OPenCV floodfill 方法解决，对floodfill 不甚理解，于是乎写了一段例子来测试它的功能，为了不让大家重复劳动，在此分享给大家。
cvFloodFill
10-26
opencv中cvFloodFill函数的用法，实现图像填充的效果
洪水覆盖算法(Flood Fill)：颜色填充
风口IT猪的成长录
05-20 1万+
Flood FillFlood FillBasic 概念相关参数实现方式典型例题颜色填充DFSBFS贪吃蛇大作战BFSDFS Flood Fill Basic 概念 洪水填充(Flood fill)算法：从一个起始节点开始把附近与其连通的节点提取出或填充成不同颜色颜色，直到封闭区域内的所有节点都被处理过为止，是从一个区域中提取若干个连通的点与其他相邻区域区分开(或分别染成不同颜色)的经典算法。 因为其思路类似洪水从一个区域扩散到所有能到达的区域而得名。 在GNU Go和扫雷中，Flood Fill算法被
常见算法之Flood Fill算法
weixin_46207366的博客
02-08 4408
常见算法之Flood Fill算法 算法介绍 基本作用：寻找连通块 基本方法：BFS 适用题目：需要找出分类块的题目 顾名思义，Flood Fill算法就是像洪水泛滥一样去寻找周围符合条件的区域，采用BFS可以完成先从自身最近的点寻找随后逐步扩展。 代码思路 设置函数bfs 传入参数坐标，创建队列，初始位置压入 将形参坐标改变，并标记已经访问（防止重复） 循环直到队列空 将队头元素取出 判断改变后的坐标是不是满足要求（范围，标记状态，属于连通块等） 若满足状态，压入队列，将状态重置 例题 池塘计数
OpenCv漫水填充floodFill详解
热门推荐
weixin_42296411的博客
07-09 3万+
函数原型int cv::floodFill ( InputOutputArray image, InputOutputArray mask, Point seedPoint, Scalar newVal, Rect * rect = 0, Scalar loDiff = Scalar(), Scalar upDiff = Scalar(), ...
0092 经典算法系列——泛洪填充（FloodFill）
gendlee1991的专栏
05-27 1858
泛洪填充（FloodFill）问题在图像处理中非常常用，它和连通图的概念相似。最近在YouTube看 Patrick Shyu (TechLead)的视频，他讲他在谷歌面试别人的时候，常会出一道泛洪填充的题。 这道题参考LeetCode733： 有一幅以二维整数数组表示的图画，每一个整数表示该图画的像素值大小，数值在 0 到 65535 之间。 给你一个坐标 (sr, sc) 表示图像渲染开始的像素值（行 ，列）和一个新的颜色值 newColor，让你重新上色这幅图像。 为了完成上色工作，从初始坐标开始，
FloodFill.zip
01-10
利用深度优先搜索或者广度优先搜素实现，地图的遍历。类似于扫雷游戏。在搜索过程中使用线程，加快了搜索效率，提高了用户体验
floodfill 区域生长法 opencv
11-24
基于vs2010与opencv采用区域生长法实现的图像分割法，经调试可用，一个挺简单的源程序，可供初学者参考
算法介绍 | 泛洪算法（Flood fill Algorithm）
Eason_Y的博客
11-10 4182
图像分割经典算法--《泛洪算法》（Flood Fill）
算法——BFS解决FloodFill算法
裙下的霸气的博客
01-04 629
中文：洪水灌溉。假设这一块4*4的方格是一块土地，有凸起的地方，也有凹陷的地方（凹陷的地方用负数表示）。此时下大雨发洪水，会把凹陷的地方填满。绿色圈起来的属于一块区域（上下左右四个方向，有时候题目也会问八个方向包括斜着相连的），题目会问有多少块区域被填满，或者问被填满的最大区域是哪个；或某一块区域的边长是多少。但是本质都是让我们在一块区域找性质相同的连通块。DFS——深度优先遍历（递归）：从某一点开始一条路走到黑。
c++中的floodfill()函数
m0_74346074的博客
03-28 674
参数表中X与Y是选取的点的坐标，color是选取的颜色，floodfill()函数就能将点(X,Y)所在的封闭图。4 - RED 红 5 - MAGENTA 洋红。函数原型：void floodfill(int X, int Y, int color);6 - BROWN 棕 7 - LIGHTGRAY 淡灰。12 - LIGHTRED 淡红 13 - LIGHTMAGENTA 淡洋红。形填充上color值所对应的颜色。
floodfill算法(洪水灌溉算法)
weixin_61518137的博客
09-09 425
一)floodfill算法简介:二)图像渲染。
opencv-python学习（九）：图片填充 — 漫水填充（floodFill）
weixin_33538887的博客
07-01 1858
一、指定颜色填充 代码如下： # 引入包 import cv2 as cv import numpy as np def fill_image(image): copyImage = image.copy() # 复制原图像 h, w = image.shape[:2] # 读取图像的宽高 mask = np.zeros([h+2, w+2], np.uint8) # 新建图像矩阵 +2是官方函数要求 #(0,80) 起始点,(0,100,255) 蓝色 ,(100,10
Flood Fill(漫水填充)算法
LinJM-机器视觉
03-20 5890
Floodfill算法即漫水填充法，是区域填充法的一种，其实质是种子填充法，这种方法适用于对内定义区域的填充。 所谓内定义区域，是指区域内部所有像素具有同一颜色或亮度值，而区域外的所有像素具有另一种颜色或亮度值。Floodfill方法能将该区域中的全部像素都设置为新值，并通过一定的规则确定一组种子点（该种子点为区域内点），然后通过判断种子点的邻域像素是否和种子构成连通域，从而决定是否对其进行填充
Unity | 泛洪算法（Flood Fill Algorithm）
持续学习！
01-25 1057
泛洪算法简介码如其名，泛洪算法的效果就是如同水一般从起始点开始向四周蔓延，直到填满连通区域中的所有位置。在Unity中，泛洪算法是一种常用的用于填充2D图像或地图中连通区域的算法。它经常被用于地图编辑、图像处理和游戏关卡生成。文章内容仅为个人学习记录。好记性不如烂笔头，为了能更好的回顾和总结，开始记录与分享自己学到的Unity知识。若文章内容错误，麻烦指点。
每周算法——搜索-Flood Fill算法
f6y6h的博客
10-16 430
洪水填充算法：从一个节点开始将附近联通的节点全部标志成一种特性，直到与之联通的节点全被标志之后停止。因其思路与大水漫灌所有其可以达到的节点而得名。虽然是一种较为简单的算法，但其在各种场景下被使用，如扫雷游戏中展开一部分区域以及windows绘画本中将圈起区域染色的油漆桶又或者是消消乐。 FloodFill算法一般是四邻域填充法和八邻域填充法，基于扫描线填充算法。 FloodFill算法可以通过BFS或者DFS实现，但在oj题目中大多使用BFS解题。原因是BFS是基于迭代而产生，DFS是递归来计算在超过1
图像分割-漫水填充法 floodFill
UruseiBest 的技术专栏
01-02 1278
FloodFill方法是一种图像处理算法，它的目的是将一个闭合的区域内的像素全部涂上同一个颜色。在实现中，通常会使用递归或队列来处理待处理列表。具体的实现方式会根据具体应用场景的需求而有所不同。CvInvoke.FloodFill方法用于执行图像的漫水填充操作，它将连通区域中的所有像素点填充为指定颜色的操作。很相似，本文也可以为C#爱好者提供参考。返回一个整数值，表示填充的像素个数。由于.net平台下C#和vb。
matlab floodFill
最新发布
04-08
在MATLAB中，floodFill是一种图像处理算法，用于填充连通区域。它可以将指定的种子点周围的像素值替换为新的值，从而实现填充效果。 MATLAB中的floodFill函数通常用于图像分割、图像编辑和图像处理等领域。它可以...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值