【Floodfill算法】dfs或者bfs解决floodfill算法

已于 2024-05-18 22:05:44 修改
阅读量350 收藏 3
点赞数 7
分类专栏： 【刷题合集】算法 文章标签： 深度优先 算法 leetcode
于 2024-05-18 21:22:16 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_78611726/article/details/139031581
版权

1.图像渲染

图像渲染

dfs解决代码：

class Solution {
public:
    int dx[4] = {0, 0, -1, 1};
    int dy[4] = {-1, 1, 0, 0};
    int m, n;
    int prev;
    vector<vector<int>> ret;
    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];
        dfs(image, sr, sc, color);
        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(x >= 0 && x < m && y >= 0 && y < n && image[x][y] == prev)
            {
                dfs(image, x, y, color);
            }
        }
    }
};

bfs解决代码：

 

class Solution {
public:
    typedef pair<int, int> PII;
    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) {
        int prev = image[sr][sc];
        if(prev == color) return image;
        int m = image.size(), n = image[0].size();
        
        queue<PII> q;
        q.push({sr, sc});
        while(!q.empty())
        {
            auto& [a, b] = q.front();
            image[a][b] = color;
            q.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)
                {
                    q.push({x, y});
                }
            }
        }
        return image;
    }
};

2.岛屿数量

岛屿数量

dfs解决代码：

class Solution {
public:
    int dx[4] = {0, 0, -1, 1};
    int dy[4] = {-1, 1, 0, 0};
    int m, n, ret;
    bool vis[301][301];
    int numIslands(vector<vector<char>>& grid) {
        m = grid.size(), n = grid[0].size();
        for(int i = 0; i < m; i++)
        {
            for(int j = 0; j < n; j++)
            {
                if(!vis[i][j] && grid[i][j] == '1')
                {
                    ret++;
                    dfs(grid, i, j);    //标记联通1
                }
            }
        }
        return ret;
    }
    void dfs(vector<vector<char>>& grid, int i, int j)
    {
        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] && grid[x][y] == '1')
            {
                dfs(grid, x, y);
            }
        }
    }
};

bfs解决代码：

class Solution {
public:
    int dx[4] = {0, 0, -1, 1};
    int dy[4] = {-1, 1, 0, 0};
    int m, n, ret;
    bool vis[301][301];
    int numIslands(vector<vector<char>>& grid) {
        m = grid.size(), n = grid[0].size();
        for(int i = 0; i < m; i++)
        {
            for(int j = 0; j < n; j++)
            {
                if(!vis[i][j] && grid[i][j] == '1')
                {
                    ret++;
                    bfs(grid, i, j);    //标记联通1
                }
            }
        }
        return ret;
    }
    void bfs(vector<vector<char>>& grid, int i, int j)
    {
        queue<pair<int, int>> q;
        q.push({i, j});
        vis[i][j] = true;

        while(q.size())
        {
            auto [a, b] = q.front();
            q.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 && !vis[x][y] && grid[x][y] == '1')
                {
                    q.push({x, y});
                    vis[x][y] = true;
                }
            }
        }
    }
};

3.岛屿的最大面积

岛屿的最大面积

dfs解决代码：

class Solution {
public:
    bool vis[51][51]; 
    int dx[4] = {0, 0, -1, 1};
    int dy[4] = {-1, 1, 0, 0};
    int m, n;
    int count;
    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(!vis[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)
    {
        count++;
        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] && grid[x][y] == 1)
            {

                dfs(grid, x, y);
            }
        }
    }
};

bfs解决代码：

class Solution {
public:
    bool vis[51][51]; 
    int dx[4] = {0, 0, -1, 1};
    int dy[4] = {-1, 1, 0, 0};
    int m, n;
    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(!vis[i][j] && grid[i][j] == 1)
                {
                    ret = max(ret, bfs(grid, i, j));
                }
            }
        }
        return ret;
    }
    int bfs(vector<vector<int>>& grid, int i, int j)
    {
        int count = 0;
        queue<pair<int, int>> q;
        q.push({i, j});
        vis[i][j] = true;
        count++;
        while(!q.empty())
        {
            auto [a, b] = q.front();
            q.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 && !vis[x][y] && grid[x][y] == 1)
                {
                    q.push({x, y});
                    vis[x][y] = true;
                    count++;
                }
            }
        }
        return count;
    }
};

4.被围绕的区域

被围绕的区域

dfs解决代码：

class Solution {
public:
    int dx[4] = {0, 0, -1, 1};
    int dy[4] = {-1, 1, 0, 0};
    int m, n;
    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] == 'O')
                    board[i][j] = 'X';
                else if(board[i][j] == '.')
                    board[i][j] = 'O';
    }
    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 dx[4] = {0, 0, -1, 1};
    int dy[4] = {-1, 1, 0, 0};
    int m, n;
    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] == 'O')
                    board[i][j] = 'X';
                else if(board[i][j] == '.')
                    board[i][j] = 'O';
    }
    void bfs(vector<vector<char>>& board, int i, int j)
    {
        queue<pair<int, int>> q;
        q.push({i, j});
        board[i][j] = '.';
        while(!q.empty())
        {
            auto [a, b] = q.front();
            q.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')
                {
                    q.push({x, y});
                    board[x][y] = '.';
                }
            }
        }
    }
};

5.太平洋大西洋水流问题

太平洋大西洋水流问题

代码：

class Solution {
public:
    int dx[4] = {0, 0, -1, 1};
    int dy[4] = {-1, 1, 0, 0};
    int m, n;
    vector<vector<int>> pacificAtlantic(vector<vector<int>>& h) {
        m = h.size(), n = h[0].size();
        vector<vector<bool>> pac(m, vector<bool>(n));
        vector<vector<bool>> atl(m, vector<bool>(n));
        //pac -- 太平洋
        for(int i = 0; i < m; i++) dfs(h, i, 0, pac);
        for(int j = 0; j < n; j++) dfs(h, 0, j, pac);
        //atl -- 大西洋
        for(int i = 0; i < m; i++) dfs(h, i, n - 1, atl);
        for(int j = 0; j < n; j++) dfs(h, m - 1, j, atl);
        vector<vector<int>> ret;
        for(int i = 0; i < m; i++)
            for(int j = 0; j < n; j++)
                if(pac[i][j] && atl[i][j])
                    ret.push_back({i, j});
        return ret;
    }
    void dfs(vector<vector<int>>& h, int i, int j, vector<vector<bool>>& vis)
    {
        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] && h[x][y] >= h[i][j])
            {
                dfs(h, x, y, vis);
            }
        }
    }
};

6.扫雷游戏

扫雷游戏

代码：

class Solution {
public:
    int dx[8] = {0, 0, -1, -1, -1, 1, 1, 1};
    int dy[8] = {-1, 1, -1, 0, 1, -1, 0, 1};
    int m, n;
    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(x >= 0 && x < m && y >= 0 && 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(x >= 0 && x < m && y >= 0 && y < n && board[x][y] == 'E')
                {
                    dfs(board, x, y);
                }
            }
        }
    }
};

7.衣橱整理

衣橱整理

代码：

class Solution {
public:
    int m, n, cnt; 
    int ret;
    bool vis[101][101];
    int dx[4] = {0, 0, -1, 1};
    int dy[4] = {-1, 1, 0, 0};
    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 sum = 0;
        while(i)
        {
            sum += i % 10;
            i /= 10;
        }
        while(j)
        {
            sum += j % 10;
            j /= 10;
        }
        return sum <= cnt;
    }
};

花影随风_
关注
专栏目录
FloodFill算法简介（用BFS、DFS算法解决）
2301_76197086的博客
04-18 644
FloodFill算法简介
FloodFill算法---DFS
2301_80035594的博客
04-25 2135
floodfill算法是一种图像处理算法，用于填充连通区域。它的作用是将指定的像素点及其相邻的相同颜色的像素点都填充为指定的颜色，从而形成一个封闭的区域。 该算法常用于图像编辑软件中的涂色功能，也可以用于图像分割、边缘检测等应用。通过floodfill算法，可以快速、自动地填充图像中的特定区域，提高图像处理的效率和准确性。 floodfill算法的基本思想是通过递归或者栈来实现。 本文章详细介绍了floodfill算法的基本用法及模板，通过经典例题帮助友友快速掌握，希望可以帮到您。
BFS：Floodfill算法
weixin_51142926的博客
07-01 3491
Floodfill，翻译为洪水灌溉，而floodfill算法本质上是为了解决在矩阵中性质相同的联通块问题。
FloodFill算法---BFS
2301_80035594的博客
05-14 1596
不知友友们是否听说过FloodFill算法，最短路径问题，拓扑排序，今天我们就要解决FloodFill算法通过 BFS，后续我们也会使用 BFS 来解决最短路径问题和拓扑排序，快来看看吧。
算法——DFS、BFS【练习】
weixin_51345990的博客
09-08 373
LeetCode的刷题总结——合并二叉树、图像渲染
FloodFill算法详解：深度优先搜索与广度优先搜索实现
此算法可以通过深度优先搜索（DFS）、广度优先搜索（BFS）或广度优先扫描（BFS Scan）来实现。" Flood_Fill算法的核心思想是通过选择一个起始节点，将其标记，并逐步扩展到与其相邻且未被标记的节点，以此创建一个...
FloodFill算法（DFS+BFS）【上】
Dirty_artist的博客
09-15 1192
733.图形渲染，200.岛屿数量，695.岛屿的最大面积，130.被围绕的区域
DFS、BFS经典例题
weixin_43962381的博客
09-13 670
文章目录深度优先搜索1.n张牌分别放进n个盒子，有几种方案2.leetcode 690 员工重要性3.leetcode 733 图像渲染4.leetcode 130 被围绕的区域5.leetcode 200 岛屿数量广度优先搜搜索1.走迷宫问题2.员工重要性3.N叉树的层序遍历 深度优先搜索 1.n张牌分别放进n个盒子，有几种方案 思路： 代码流程： DFS() { 处理边界，向上回退 尝试当前的每一种可能 确定一种可能后，递归处理下一步----DFS(下一步) 回收本次处理结果 } #include
算法——BFS解决FloodFill算法
裙下的霸气的博客
01-04 928
中文：洪水灌溉。假设这一块4*4的方格是一块土地，有凸起的地方，也有凹陷的地方（凹陷的地方用负数表示）。此时下大雨发洪水，会把凹陷的地方填满。绿色圈起来的属于一块区域（上下左右四个方向，有时候题目也会问八个方向包括斜着相连的），题目会问有多少块区域被填满，或者问被填满的最大区域是哪个；或某一块区域的边长是多少。但是本质都是让我们在一块区域找性质相同的连通块。DFS——深度优先遍历（递归）：从某一点开始一条路走到黑。
50_floodFill2_漫水填充算法_
10-03
8. **效率优化**：为了提高效率，可以使用宽度优先搜索（BFS）或深度优先搜索（DFS），并考虑使用掩码或位运算来快速判断相邻像素。 9. **错误处理**：在实际应用中，可能需要处理用户输入错误、图像格式错误等问题...
【FloodFill算法】DFS
cefler的博客
01-15 498
【FloodFill算法】DFS
岛屿个数（dfs)
初九·潜龙勿用的博客
04-07 5169
小蓝得到了一副大小为M×N的格子地图，可以将其视作一个只包含字符0（代表海水）和1（代表陆地）的二维数组，地图之外可以视作全部是海水，每个岛屿由在上/下/左/右四个方向上相邻的1相连接而形成。x0​y0​x1​y1​...xk−1​yk−1​，其中 (x,y) 是由xi​yi​通过上/下/左/右移动一次得来的 (0≤i≤k−1)，此时这 k 个格子就构成了一个 “环”。
100种算法【Python版】第36篇——Graham Scan算法
AnFany
11-02 265
100种算法【Python版】第36篇——Graham Scan算法
算法基础-链表
August的专栏
11-05 202
当链表的长度为偶数时，head找到的中点是靠后的，因为fast相对slow移动只快了1步，而head.next找到的中点是靠前的，因为fast相对slow移动快了2步。这2种方式寻找链表的结点主要区别是 当链表的长度为奇偶数时，找到链表中点的位置一个靠后，一个靠前。使用快慢指针寻找链表的中点有2种方式，分别是fast=head;当链表为奇数时 [1->2->3->4->5]当链表长度为奇数时，找到的中点2种方式是一样的。当链表为偶数时 [1->2->3->4]
100种算法【Python版】第51篇——希尔排序
AnFany
11-06 204
100种算法【Python版】第51篇——希尔排序
字符串-06-整数与ip地址之间的转换
qq_45480682的博客
11-04 302
华为od算法——HJ33
CSP/信奥赛C++刷题训练：经典深搜例题（1）：洛谷1605 ：迷宫
weixin_66461496的博客
11-02 1025
CSP/信奥赛C++刷题训练：经典深搜例题（1）：洛谷1605 ：迷宫
【LeetCode】【算法】160.相交链表
passer__jw767的博客
11-05 271
Leetcode 160. 相交链表
【算法】（Python）贪心算法
yannan20190313的博客
11-04 1822
【算法】（Python）贪心算法（最大单元数，买卖股票最佳时机，最低加油次数）
二分查找习题篇(上)
最新发布
zoelinkailuo的博客
11-07 514
给定⼀个 n 个元素有序的（升序）整型数组 nums 和一个目标值 target ，写一个函数搜索 nums 中的 target，如果目标值存在返回下标，否则返回 -1。这里，我们把数组的元素分为两部分——小于等于target的部分[left,Bright] and 大于target的部分[Bright+1,right]。这里，我们把数组的元素分为两部分——平方后小于等于x的部分[1,mid] and 平方后大于x的部分[mid-1, x]和一个目标值，在数组中找到目标值，并返回其索引;
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

花影随风_

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

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

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

打赏作者

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

抵扣说明：

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

余额充值