FloodFill 算法（DFS）

最新推荐文章于 2025-05-12 23:16:27 发布
最新推荐文章于 2025-05-12 23:16:27 发布
阅读量916 收藏 13
点赞数 33
分类专栏： 算法 文章标签： 算法 深度优先 c++ 递归
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_74317866/article/details/142986171
版权

文章目录

FloodFill 算法（DFS）

漫水填充(Flood Fi)算法是一种图像处理算法，在计算机图形学和计算机视觉中被广泛应用。它用于填充图像中的连通区域，从一个种子点开始，沿着相邻的像素进行填充操作，直到达到某个停止条件为止。该算法可以实现图像填充、颜色替换、图像分割等操作。

图像渲染

题目：图像渲染

在这里插入图片描述

思路

从起点开始深度优先搜索，当遇到上下左右和当前一样时，即为合法目标，将其修改为color，用一个标记数组visited来判断当前位置是否访问过

C++代码

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

        m = image.size(), n = image[0].size();
        prev = image[sr][sc];

        visited[sr][sc] = true;
        dfs(image, sr, sc, color);
        visited[sr][sc] = false;

        return image;
    }
    void dfs(vector<vector<int>>& image, int i, int j, int color)
    {
        image[i][j] = color;
        for(int k = 0; k < 4; k++)
        {
            int x = i + dx[k], y = j + dy[k];
            if(0 <= x && x < m && 0 <= y && y < n && !visited[x][y] && image[x][y] == prev)
            {
                visited[x][y] = true;
                dfs(image, x, y, color);
                visited[x][y] =false;
            }
        }
    }
};

岛屿数量

题目：岛屿数量

在这里插入图片描述
思路

遍历数组，找到1开始搜索，搜索一次答案++，遍历过后用一个标记数组visited标记该位置

C++代码

class Solution 
{
    int dx[4] = {0, 0, 1, -1};
    int dy[4] = {1, -1, 0, 0};
    int m, n;
    bool visited[301][301];
public:
    int numIslands(vector<vector<char>>& grid) 
    {
        m = grid.size(), n = grid[0].size();
        int ret = 0;
        for(int i = 0; i < m; i++)
            for(int j = 0; j < n; j++)
            {
                if(!visited[i][j] && grid[i][j] == '1')
                {
                    ret++;
                    dfs(grid, i, j);
                }
            }

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

岛屿的最大面积

题目：岛屿的最大面积

在这里插入图片描述
思路

和岛屿数量解题思路一样，只不过在每次遍历岛屿的时候，用一个变量count来统计当前岛屿的大小，并变量完当前岛屿后，和之前最大的结果ret取一个最大值

C++代码

class Solution 
{
    bool visited[51][51];
    int dx[4] = {0, 0, 1, -1};
    int dy[4] = {1, -1, 0, 0};
    int m, n;
    int count;
public:
    int maxAreaOfIsland(vector<vector<int>>& grid) 
    {
        m = grid.size(), n = grid[0].size();
        int ret = 0;
        for(int i = 0; i < m; i++)
            for(int j = 0; j < n; j++)
                if(!visited[i][j] && grid[i][j] == 1)
                {
                    count = 0;
                    dfs(grid, i, j);
                    ret = max(ret, count);
                }

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

被围绕的区域

题目：被围绕的区域

在这里插入图片描述
思路

和岛屿数量解题思路一样，只不过在每次遍历岛屿的时候，用一个变量count来统计当前岛屿的大小，并变量完当前岛屿后，和之前最大的结果ret取一个最大值

C++代码

class Solution 
{
    int dx[4] = {0,0,1,-1};
    int dy[4] = {-1,1,0,0};
    int m, n;
public:
    void solve(vector<vector<char>>& board) 
    {
        m = board.size(), n = board[0].size();

        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 = 1; i < n - 1; i++)
        {
            if(board[0][i] == 'O') dfs(board, 0, i);
            if(board[m - 1][i] == 'O') dfs(board, m - 1, i);
        }

        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(0 <= x && x < m && 0 <= y && y < n && board[x][y] == 'O')
            {
                dfs(board, x, y);
            }
        }
    }
};

太平洋大西洋水流问题

题目：太平洋大西洋水流问题

在这里插入图片描述
思路

  • 对于太平洋边界（即第一行和第一列）上的每个单元格，将其标记为可达太平洋toPO = true，并将其加入队列进行DFS。在DFS过程中，如果当前单元格的相邻单元格高度不低于当前单元格，且未被标记为可达太平洋，则将其标记为可达太平洋，并加入队列继续搜索
  • 对于大西洋边界（即最后一行和最后一列）上的每个单元格，进行类似的操作，将其标记为可达大西洋toAO= true
  • 遍历整个矩阵，对于每个单元格，如果它同时被标记为可达太平洋和可达大西洋toPO && toAO，则将其坐标加入结果列表。

C++代码

class Solution 
{
    int dx[4] = {0, 0, 1, -1};
    int dy[4] = {1, -1, 0, 0};
    int m, n;
    bool toPO[201][201];
    bool toAO[201][201];
    vector<vector<int>> ret;
public:
    vector<vector<int>> pacificAtlantic(vector<vector<int>>& heights) 
    {
        m = heights.size(), n = heights[0].size();
        // 左、上
        for(int i = 0; i < m; i++) dfs(heights, i, 0, toPO);
        for(int i = 0; i < n; i++) dfs(heights, 0, i, toPO);

        // 右、下
        for(int i = 0; i < m; i++) dfs(heights, i, n - 1, toAO);
        for(int i = 0; i < n; i++) dfs(heights, m - 1, i, toAO);

        for(int i = 0; i < m; i++)
            for(int j = 0; j < n; j++)
                if(toPO[i][j] && toAO[i][j]) ret.push_back({i, j});

        return ret;
    }
    void dfs(vector<vector<int>>& heights, int i, int j, bool visited[201][201])
    {
        visited[i][j] = true;
        for(int k = 0; k < 4; k++)
        {
            int x = i + dx[k], y = j + dy[k];
            if(0 <= x && x < m && 0 <= y && y < n && !visited[x][y] && heights[x][y] >= heights[i][j])
                dfs(heights, x, y, visited);
        }
    }
};

扫雷游戏

题目：扫雷游戏

在这里插入图片描述
思路

理解题目意思，模拟+深度优先搜索

C++代码

class Solution
{
    int dx[8] = {0, 0, 1, 1, 1, -1, -1, -1};
    int dy[8] = {1, -1, 0, 1, -1, 0, 1, -1};
    int m, n;
public:
    vector<vector<char>> updateBoard(vector<vector<char>>& board, vector<int>& click)
    {   
        m = board.size(), n = board[0].size();
        int x = click[0], y = click[1];
        if(board[x][y] == 'M')
        {
            board[x][y] = 'X';
            return board;
        }
        dfs(board, x, y);
        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(0 <= x && x < m && 0 <= y && y < n && board[x][y] == 'M')
            {
                count++;
            }
        }

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

衣橱整理

题目：衣橱整理

在这里插入图片描述

思路

模拟+DFS

C++代码

class Solution 
{
    int ret;
    bool vis[101][101];
    int dx[4] = {0, 1};
    int dy[4] = {1, 0};
    int m, n, cnt;
public:
    int wardrobeFinishing(int _m, int _n, int _cnt) 
    {
        m = _m, n = _n, cnt = _cnt;
        dfs(0, 0);
        return ret;
    }
    void dfs(int i, int j)
    {
        ret++;
        vis[i][j] = true;
        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 && !vis[x][y] && check(x,y))
            {
                dfs(x, y);
            }
        }
    }
    bool check(int i,int j)
    {
        int tmp = 0;
        while(i)
        {
            tmp += i % 10;
            i /= 10;
        }
        while(j)
        {
            tmp += j % 10;
            j /= 10;
        }
        return tmp <= cnt;
    }
};
FloodFill算法详解及应用
wolfGuiDao的博客
03-07 8215
FloodFill算法详解及应用 啥是 FloodFill 算法呢， 最直接的一个应用就是「颜色填充」，就是 Windows 绘画本中 那个小油漆桶的标志，可以把一块被圈起来的区域全部染色。 这种算法思想还在许多其他地方有应用。比如说扫雷游戏，有时候你点一个方格， 会一下子展开一片区域，这个展开过程，就是 FloodFill 算法实现的。 类似的，像消消乐这类游戏，相同方块积累到一定数量，就全...
Flood Fill(漫水填充)算法
LinJM-机器视觉
03-20 6177
Floodfill算法即漫水填充法，是区域填充法的一种，其实质是种子填充法，这种方法适用于对内定义区域的填充。 所谓内定义区域，是指区域内部所有像素具有同一颜色或亮度值，而区域外的所有像素具有另一种颜色或亮度值。Floodfill方法能将该区域中的全部像素都设置为新值，并通过一定的规则确定一组种子点（该种子点为区域内点），然后通过判断种子点的邻域像素是否和种子构成连通域，从而决定是否对其进行填充
Flood Fill（漫水法）+ 最短路模型
ker的博客
07-06 1249
文章目录 对于一张地图，使用Flood Fill就可以找到最大连通子图，可以使用BFS、DFS来实现，这里使用BFS演示。 可以在线性时间复杂度（O（nm)）内，找到某个点所在的连通块（所有边权重相等） 例题： 城堡问题 图1是一个城堡的地形图。 请你编写一个程序，计算城堡一共有多少房间，最大的房间有多大。 城堡被分割成 m∗n个方格区域，每个方格区域可以有0~4面墙。 注意：墙体厚度忽略不计。 输入格式 第一行包含两个整数 m 和 n，分别表示城堡南北方向的长度和东西方向的长度。 接下来 m 行，
【Opencv】漫水填充floodFill详解
mjiansun的专栏
11-25 1169
https://blog.csdn.net/weixin_42296411/article/details/80966724 函数原型 参数 image 【输入/输出】 1或者3通道、 8bit或者浮点图像。仅当参数flags的FLOODFILL_MASK_ONLY标志位被设置时image不会被修改，否则会被修改。 mask 【输入/输出】 操作掩码，必须...
flood fill算法
多看多听多总结
02-13 544
flood fill算法实现有三种形式 1、depth first search 2、breadth first search 3、breadth first scan 基本思想是找到还没有分配component的结点，并且计算哪个componetn包含此结点。 深度优先搜索算法是通过当前结点的所有邻接结点查找一步，对于还没有分配component的结点，赋值相应的component，然...
探索复杂形状的实例分割：Flood-Filling Networks (FFNs) 项目推荐
gitblog_00396的博客
09-26 833
探索复杂形状的实例分割：Flood-Filling Networks (FFNs) 项目推荐 ffn Flood-Filling Networks for instance segmentation in 3d volumes. ...
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(), ...
floodfill算法（DFS，BFS）
2301_80224556的博客
12-10 799
啥是 FloodFill 算法呢，最直接的一个应用就是「颜色填充」，就是 Windows 绘画本中那个小油漆桶的标志，可以把一块被圈起来的区域全部染色。这种算法思想还在许多其他地方有应用。比如说扫雷游戏，有时候你点一个方格，会一下子展开一片区域，这个展开过程，就是 FloodFill 算法实现的。类似的，像消消乐这类游戏，相同方块积累到一定数量，就全部消除，也是 FloodFill 算法的功劳。通过以上的几个例子，你应该对 FloodFill 算法有个概念了，现在我们要抽象问题，提取共同点。
算法：DFS解决FloodFill算法
一名还在努力学习技术的程序员的博客
08-15 1086
本篇博客是关于 DFS解决floodfill算法 的练习题，每道题都超链接了力扣的网页，每道题都有详细的解答过程
如何应用离散化算法来计算平面内多个圆覆盖的总面积？请提供一个基于Floodfill和DFS的算法设计示例。
11-11
首先，通过建立足够密度的点阵图，可以利用Floodfill算法标记出所有由圆覆盖的区域。具体操作是，在每个圆的内部和边缘选择一个起始点，进行深度优先遍历，从而找到所有与之连通的点。每个被标记的点代表该点在至少...
FloodFill（泛洪算法）
lynne233
01-09 1万+
泛洪算法图形处理中的一个填充算法，我们可以设想这样一个场景，windows的画图软件中的油漆桶为一个形状着色，该形状的范围内都将被着色，我们所使用的算法就是从一个像素点出发，以此向周边的像素点扩充着色，直到图形的边界。这个场景我们使用的算法就是flood fill(泛洪算法)。 泛洪算法有3中不同的方式，每种算法有两种形式一种是递归的一种是非递归的。一般来说对于递归的算法我们比较容易实现，但是若
洪水填充算法_洪水填充(Flood fill)算法
weixin_32136203的博客
02-12 7505
标签：洪水填充(Flood fill)算法从一个起始节点开始把附近与其连通的节点提取出或填充成不同颜色颜色，直到封闭区域内的所有节点都被处理过为止，是从一个区域中提取若干个连通的点与其他相邻区域区分开(或分别染成不同颜色)的经典算法。因为其思路类似洪水从一个区域扩散到所有能到达的区域而得名。在GNU Go和扫雷中，Flood Fill算法被用来计算需要被清除的区域。洪水填充算法接受三个参数：起始节...
图像处理之泛洪填充算法(Flood Fill Algorithm)
weixin_33726318的博客
05-10 1579
泛洪填充算法(Flood Fill Algorithm) 泛洪填充算法又称洪水填充算法是在很多图形绘制软件中常用的填充算法，最熟悉不过就是 windows paint的油漆桶功能。算法的原理很简单，就是从一个点开始附近像素点，填充成新 的颜色，直到封闭区域内的所有像素点都被填充新颜色为止。泛红填充实现最常见有四邻域 像素填充法，八邻域像素填充法，基于扫描线的像素填充方...
常见算法之Flood Fill算法
weixin_46207366的博客
02-08 4879
常见算法之Flood Fill算法 算法介绍 基本作用：寻找连通块 基本方法：BFS 适用题目：需要找出分类块的题目 顾名思义，Flood Fill算法就是像洪水泛滥一样去寻找周围符合条件的区域，采用BFS可以完成先从自身最近的点寻找随后逐步扩展。 代码思路 设置函数bfs 传入参数坐标，创建队列，初始位置压入 将形参坐标改变，并标记已经访问（防止重复） 循环直到队列空 将队头元素取出 判断改变后的坐标是不是满足要求（范围，标记状态，属于连通块等） 若满足状态，压入队列，将状态重置 例题 池塘计数
OpenCV源码解析：FloodFill（漫水填充）函数
tanmx219的博客
08-09 4422
花木成畦手自栽 ！ 先来两张wikipedia上的图，分别为4连通填充和8连通填充的示意图。 FloodFill，一般的翻译是漫水填充，也就是把相邻的满足填充要求的颜色换成某个颜色的过程。填充方式一般是4连通，也就是扩展方向是上下左右4个方向， 当然你也可以采用8连通填充，把角上那4个也包括进来 直观地来说，可以这样填充， 以stack堆栈为基础的递归填充 一个很简单的...
OpenCV3之——漫水填充：floodFill函数
衣带渐宽人憔悴
07-25 1万+
定义 ：          漫水填充算法是一种用特定颜色填充连通区域，通过设置像素上下限及连通方式来达到不同的连通效果。漫水填充经常用来标记或分离图像的一部分，以便于对其进行进一步的处理和分析。也可以从输入图像获取掩码区域，掩码会加速处理过程，或只处理掩码指定的像素点，操作的结果总是某个连续的区域。 基本思想：          所谓漫水填充，简单来说，就是自动选中了和种子点相连的区域，接着...
洪水覆盖算法(Flood Fill)：颜色填充
风口IT猪的成长录
05-20 1万+
Flood FillFlood FillBasic 概念相关参数实现方式典型例题颜色填充DFSBFS贪吃蛇大作战BFSDFS Flood Fill Basic 概念 洪水填充(Flood fill)算法：从一个起始节点开始把附近与其连通的节点提取出或填充成不同颜色颜色，直到封闭区域内的所有节点都被处理过为止，是从一个区域中提取若干个连通的点与其他相邻区域区分开(或分别染成不同颜色)的经典算法。 因为其思路类似洪水从一个区域扩散到所有能到达的区域而得名。 在GNU Go和扫雷中，Flood Fill算法被
【OpenCV入门教程之十五】水漫金山：OpenCV漫水填充算法（Floodfill）
热门推荐
【浅墨的游戏编程Blog】毛星云（浅墨）的专栏
06-03 13万+
本篇文章中，我们一起探讨了OpenCV填充算法中漫水填充算法相关的知识点，以及了解了OpenCV中实现漫水填充算法的两个版本的floodFill函数的使用方法，此博文一共有两个个配套的示例程序，其详细注释过的代码都在文中贴出，且文章最后提供了综合示例程序的下载。 先尝鲜一下其中一个示例程序的运行截图：  一、引言漫水填充法是一种用特定的颜色填充联通区域，通过设置可连通像素的上下限以及连通方式来达到
力扣 旋转图像
最新发布
fancy166166的博客
05-12 217
创建一个新的数组，存储旋转后的数组，将数组的第一行存到新创的数组空间的最后一列。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值