【递归、搜索与回溯】DFS解决FloodFill算法

已于 2024-07-25 13:39:04 修改
阅读量732 收藏 14
点赞数 16
分类专栏： 数据结构和算法 # 算法 文章标签： 算法 深度优先 FloodFill c++
于 2024-06-13 08:21:31 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zty857016148/article/details/139640811
版权

一、经验总结

之前我们已经研究过了BFS解决FloodFill算法：【优选算法】BFS解决FloodFill算法-CSDN博客

DFS只是遍历顺序发生了变化，其他需要注意的点大差不差。

二、相关编程题

2.1 图像渲染

题目链接

733. 图像渲染 - 力扣（LeetCode）

题目描述

在这里插入图片描述

算法原理

以给定的初始坐标为起点开始进行DFS，将遍历到的每个位置都修改为新的颜色值（可以防止重复遍历）。需要注意的是，如果修改前后的颜色值相同则会出现重复遍历以至于死循环的结果，所以要进行特殊处理。

编写代码

class Solution {
    int dx[4] = {1, -1, 0, 0};
    int dy[4] = {0, 0, 1, -1};
    int m, n, oldcolor, newcolor;
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();
        newcolor = color, oldcolor = image[sr][sc];
        image[sr][sc] = newcolor;
        DFS(image, sr, sc);
        return image;
    }

    void DFS(vector<vector<int>>& image, int sr, int sc)
    {
        for(int i = 0; i < 4; ++i)
        {
            int x=sr+dx[i], y = sc+dy[i];
            if(x>=0 && x<m && y>=0 && y<n && image[x][y]==oldcolor)
            {
                image[x][y] = newcolor;
                DFS(image, x, y);
            }
        }
    }
};

2.2 岛屿数量

题目链接

200. 岛屿数量 - 力扣（LeetCode）

题目描述

在这里插入图片描述

算法原理

在这里插入图片描述

遍历grid数组，当遇到未访问的陆地时：

  1. 统计岛屿数量
  2. 以该位置为起点进行深度优先遍历，遍历整个连通块
  3. 将整个连通块中的所有陆地都标记为已访问

编写代码

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

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

2.3 岛屿的最大面积

题目链接

695. 岛屿的最大面积 - 力扣（LeetCode）

题目描述

在这里插入图片描述

算法原理

同上一题基本相同，之不过需要多添加一个变量用于统计每个岛屿的面积。最终返回岛屿的最大面积。

编写代码

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

    void DFS(vector<vector<int>>& grid, int r, int c)
    {
        ++tmp;
        visited[r][c] = true;
        for(int i = 0; i < 4; ++i)
        {
            int x=r+dx[i], y=c+dy[i];
            if(x>=0 && x<m && y>=0 && y<n && grid[x][y]==1 && !visited[x][y])
            {
                DFS(grid, x, y);
            }
        }
    }
};

2.4 被围绕的区域

题目链接

130. 被围绕的区域 - 力扣（LeetCode）

题目描述

在这里插入图片描述

算法原理

在这里插入图片描述

编写代码

class Solution {
    int m, n;
    int dx[4] = {0, 0, 1, -1};
    int dy[4] = {1, -1, 0, 0};
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 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)
        {
            for(int j = 0; j < n; ++j)
            {
                if(board[i][j] == 'O') board[i][j] = 'X';
                if(board[i][j] == '.') board[i][j] = 'O';
            }
        }
    }

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

2.5 太平洋大西洋水流问题

题目链接

417. 太平洋大西洋水流问题 - 力扣（LeetCode）

题目描述

在这里插入图片描述

算法原理

  1. 统计太平洋水流：以紧邻太平洋的水域（第一行和第一列）为起点逆着水流的方向（>=）进行深度优先遍历，将DFS访问过的水域标记在pacific哈希表。
  2. 统计大西洋水流：以紧邻大西洋的水域（最后一行和最后一列）为起点逆着水流的方向（>=）进行深度优先遍历，将DFS访问过的水域标记在atlantic哈希表。
  3. 找到太平洋和大西洋水流的交集，返回结果。

编写代码

class Solution {
    int m, n;
    int dx[4] = {0, 0, 1, -1};
    int dy[4] = {1, -1, 0, 0};
    vector<vector<bool>> pacific;
    vector<vector<bool>> atlantic;
public:
    vector<vector<int>> pacificAtlantic(vector<vector<int>>& heights) {
        m = heights.size(), n = heights[0].size();
        pacific.resize(m, vector<bool>(n, false));
        atlantic.resize(m, vector<bool>(n, false));
        vector<vector<int>> ret;
        for(int i = 0; i < m; ++i)
        {
            if(!pacific[i][0]) DFS(heights, pacific, i, 0);
            if(!atlantic[i][n-1]) DFS(heights, atlantic, i, n-1);
        }
        for(int j = 0; j < n; ++j)
        {
            if(!pacific[0][j]) DFS(heights, pacific, 0, j);
            if(!atlantic[m-1][j]) DFS(heights, atlantic, m-1, j);
        }

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

    void DFS(vector<vector<int>>& heights, vector<vector<bool>>& ocean, int r, int c)
    {
        ocean[r][c] = true;
        for(int i = 0; i < 4; ++i)
        {
            int x=r+dx[i], y=c+dy[i];
            if(x>=0 && x<m && y>=0 && y<n && !ocean[x][y] && heights[x][y]>=heights[r][c])
            {
                DFS(heights, ocean, x, y);
            }
        }
    }
};

2.6 扫雷游戏

题目链接

529. 扫雷游戏 - 力扣（LeetCode）

题目描述

在这里插入图片描述

算法原理

见代码

编写代码

class Solution {
    //注意：有8个方向的向量
    int dx[8] = {0, 0, 1, -1, 1, -1, 1, -1}; 
    int dy[8] = {1, -1, 0, 0, 1, -1, -1, 1};
    int m, n;
public:
    vector<vector<char>> updateBoard(vector<vector<char>>& board, vector<int>& click) {
        int sr = click[0], sc = click[1];
        if(board[sr][sc] == 'M') //点中雷直接返回
        {
            board[sr][sc] = 'X';
            return board;
        }
        m = board.size(), n = board[0].size();
        DFS(board, sr, sc);
        return board;
    }

    void DFS(vector<vector<char>>& board, int r, int c)
    {
        //统计点击位置周围的地雷数量
        int cnt = 0;
        for(int i = 0; i < 8; ++i)
        {
            int x=r+dx[i], y=c+dy[i];
            if(x>=0 && x<m && y>=0 && y<n && board[x][y]=='M')
                ++cnt;
        }

        if(cnt == 0) //周围没有地雷，向四周继续拓展
        {
            board[r][c] = 'B';
            for(int i = 0; i < 8; ++i)
            {
                int x=r+dx[i], y=c+dy[i];
                if(x>=0 && x<m && y>=0 && y<n && board[x][y]=='E')
                    DFS(board, x, y);
            }
        }
        else //周围有地雷，标记周围地雷的数量
            board[r][c] = cnt+'0';
    }
};

2.7 衣橱整理

题目链接

LCR 130. 衣橱整理 - 力扣（LeetCode）

题目描述

在这里插入图片描述

算法原理

略

编写代码

class Solution {
    int ret;
    int _m, _n, _cnt;
    int dx[4] = {0, 0, 1, -1};
    int dy[4] = {1, -1, 0, 0};
    bool visited[100][100];
public:
    int wardrobeFinishing(int m, int n, int cnt) {
        _m = m, _n = n, _cnt = cnt;
        DFS(0, 0);
        return ret;
    }

    void DFS(int r, int c)
    {
        visited[r][c] = true;
        ++ret;
        for(int i = 0; i < 4; ++i)
        {
            int x=r+dx[i], y=c+dy[i];
            if(x>=0 && x<_m && y>=0 && y<_n && !visited[x][y] && digit(x)+digit(y)<=_cnt)
                DFS(x, y);
        }
    }

    int digit(int num)
    {
        int sum = 0;
        while(num > 0)
        {
            sum+=num%10;
            num/=10;
        }
        return sum;
    }
};
52Hertz_Echo
关注
专栏目录
写一个递归与回溯算法
悦分享
07-21 645
写一个递归与回溯算法 在我们生活中的树就是一种递归的结构，或者说只要形成了树结构的都可以用递归的方式来处理遍历。主枝干会有很多的分支，每一个分支和主干一样也同样会有其他更多的子分支，每一个更小的分支还会有更多的子分支... 递归本质就是遍历整颗树的一种方式(一个不差的扫描树的每一个叶子获取所有的可能性都这也是递归存在的意义)，从主干开始遍历整颗树和从某一个分支遍历所在的子树本质是一样的，不过是...
FloodFill算法详解及应用
wolfGuiDao的博客
03-07 8067
FloodFill算法详解及应用 啥是 FloodFill 算法呢， 最直接的一个应用就是「颜色填充」，就是 Windows 绘画本中 那个小油漆桶的标志，可以把一块被圈起来的区域全部染色。 这种算法思想还在许多其他地方有应用。比如说扫雷游戏，有时候你点一个方格， 会一下子展开一片区域，这个展开过程，就是 FloodFill 算法实现的。 类似的，像消消乐这类游戏，相同方块积累到一定数量，就全...
【递归、搜索与回溯】floodfill算法一
fight_p的博客
06-23 1608
floodfill算法又叫洪水灌溉或者洪水淹没啥的，这个算法比如有一个区域，负数表示低谷，0表示平原，正数表示山峰。此时发大水把这些区域淹了。其中平原和山峰可能不会改变，但是低谷水位就要上升。这种类型题目就是，我们要在这个区域中找出水位会上升的区域或者说找到会被洪水淹的区域。其实这道题说白了就是把性质相同的一个连通块找出来。比如这里就是把所有是负数的连通块找到，注意只能上下左右相连，斜着不能连！floodfill算法解决的问题就这么简单，它解决方法也非常简单，可以用深度优先遍历和宽度优先遍历。
【递归、搜索与回溯】floodfill算法二
fight_p的博客
06-25 800
【递归、搜索与回溯】floodfill算法二
递归、搜索与回溯算法：FloodFill 算法
2301_79881188的博客
04-24 714
算法思路：可以利⽤「深搜」或者「宽搜」，遍历到与该点相连的所有「像素相同的点」，然后将其修改成指定的像素即可。全局变量：int m, n;//记录原先的颜色递归函数设计：void dfs(vector<vector<int>>& image,int i,int j,int color)•参数：a.原始矩阵；b.当前所在的位置；c.需要修改成的颜⾊。•函数体：a.先将该位置的颜⾊改成指定颜⾊（因为我们的判断，保证每次进⼊递归的位置都是需要修改的位置）；b.
【递归、回溯专题（二）】DFS解决floodfill算法
Pau_0618的博客
09-01 741
从二维数组的边界开始搜索，当后面的节点的值 >= 当前节点的值就往后面搜索。搜索完之后两个vis数组都有从边界搜索到达的最远位置被标记，找到两个vis数组公共位置都被标记为true的即为既可流向太平洋也可流向大西洋。以一个元素为例，如图元素5的dfs过程中：用一个vis数组记录使用过的节点，并且dfs只能往节点值较低的或者相等的去搜。dfs负责将陆地1周围的连通区域(上下左右是1的区域)标记为true，当周围遇到了海洋0，dfs终止。此时，在函数外侧则去统计岛屿的数目(区域是1，并且区域未被标记)。
32.递归、搜索、回溯之floodfill算法
m0_47017197的博客
09-17 468
图像渲染。
FloodFill算法---DFS
2301_80035594的博客
04-25 2179
floodfill算法是一种图像处理算法，用于填充连通区域。它的作用是将指定的像素点及其相邻的相同颜色的像素点都填充为指定的颜色，从而形成一个封闭的区域。 该算法常用于图像编辑软件中的涂色功能，也可以用于图像分割、边缘检测等应用。通过floodfill算法，可以快速、自动地填充图像中的特定区域，提高图像处理的效率和准确性。 floodfill算法的基本思想是通过递归或者栈来实现。 本文章详细介绍了floodfill算法的基本用法及模板，通过经典例题帮助友友快速掌握，希望可以帮到您。
算法篇：递归、搜索与回溯算法
RTX__90的博客
02-02 1197
②怎么实现：添加一个备忘录，把结果放到备忘录里面，在每次进入递归的时候向备忘录里查找一下。80%可以用前者的思考方式，但有些题用暴搜的时间成本太高了（暴搜只是为我们确定状态表示提供方向）。不是的，只有在递归的过程中，出现了大量的完全相同的问题时，才能用记忆化搜索的方式优化。②带备忘录的递归 vs 带备忘录的动态规划 vs 记忆化搜索？②从头开始的任意一个字串，左括号的数量>=右括号的数量。①所有的递归（暴搜、深搜），都能改成记忆化搜索吗？①左括号的数量=有括号的数量。
【递归回溯之floodfill算法专题练习】
qq_64446981的博客
08-28 393
正难则反，我们可以四周开始向里面遍历，但凡能深搜到的，都是不能修改的，此时我们将遍历到的标记一下，其余的全部修改成x即可。
递归,搜索与回溯40道算法题
有时间要学习的博客
09-28 339
先进行画图分析N=2时，为了最下面的盘子解放，我们直接将（一个）盘子移到B上而N=3时，为了最下面的盘子解放，(参考N=2)然后我们将最大（解放）的盘子移到C上，那下一步呢？
回溯算法DFS应用
Emperor10的博客
11-13 1493
文章目录一、算法思想二、算法模板三、经典例题 一、算法思想 回溯算法实际上是将多叉树结构的问题，采用类似枚举的方式，把问题的所有可能性全部罗列出来。当在搜索的过程中发现不满足给定条件的选项，就将该分支去掉，这个操作通常被称为“剪枝”，再回退到上一步（回溯），尝试别的路径，直到最后找完所有路径。 二、算法模板 将问题转化为多叉树结构 三、经典例题 ...
递归、分治与回溯算法实验详解：从查找到8皇后
涵盖Floodfill、电子老鼠闯迷宫等多种搜索策略，如深度优先搜索（DFS）和广度优先搜索（BFS）。通过这些实验，学生可以掌握如何在复杂环境中寻找路径或解决问题。 实验四：动态规划 动态规划是通过将大问题分解为子...
LeetCode-题目详解（十一）：回溯算法【递归回溯、迭代回溯】【DFS是一个劲往某一个方向搜索；回溯算法建立在DFS基础之上，在搜索过程中，达到结束/裁剪条件后，恢复状态，回溯上一层，再次搜索】
u013250861的博客
06-14 480
DFS 是一个劲的往某一个方向搜索，而回溯算法建立在 DFS 基础之上的，但不同的是在搜索过程中，达到结束条件后，恢复状态，回溯上一层，再次搜索。因此回溯算法与 DFS 的区别就是有无状态重置「回溯法」实际上一个类似枚举的搜索尝试过程，主要是在搜索尝试过程中寻找问题的解，当发现已不满足求解条件时，就「回溯」返回，尝试别的路径。回溯法是一种算法思想，而递归是一种编程方法，回溯法可以用递归来实现。回溯法的整体思路是：搜索每一条路，每次回溯是对具体的一条路径而言的。对当前搜索路径下的的未探索区域进行搜索，则可能有
C++入门基础知识150—【关于C++ 输入/输出运算符重载】
zhaoylzy的博客
11-16 916
关于【C++输入/输出运算符重载】 一、什么是输入/输出运算符 二、什么是输入输出运算符重载 三、输入输出运算符重载格式 四、输入输出运算符重载参数之间的区别 五、重载提取运算符 >> 和插入运算符
1163：阿克曼(Ackmann)函数
呆萌很的博客
11-12 263
1163：阿克曼(Ackmann)函数
数据库范式、MySQL 架构、算法与树的深入解析
lrh35的博客
11-11 1330
在数据库设计中，范式是一系列规则，用于确保数据的组织和存储具有良好的结构、完整性以及最小化的数据冗余。如果不遵循范式设计，数据可能会以平铺式罗列，仅使用冒号、分号等简单分隔。这种方式存在诸多弊端，例如在数据搜索时极为不便，数据修改也会变得十分棘手。由此，范式的概念应运而生。
【循环测试试题3】小X与数字三角形
最新发布
Lonely_Boos的博客
11-16 95
共n行，第i行包含i个正整数，每个整数占五列。读入一个正整数n，输出一个n行的数字三角形。一行一个正整数n，2
【数据结构】快排之三路划分
2301_79633555的博客
11-13 427
在之前快排是排完序把key放在中间，左边比key值小，右边比key大，跟key相等的值在哪里并没有规定，跟key相等的值可以在左边，也可以在右边。因为假如cur没有遇见比key大的值，right没有--，那么cur与right在相同位置时，并不能确定right所指向的值是否小于key。但是，有些场景下hoae和lomuto（前后指针法）还是适应的不是很好，就是当数组中有大量重复数据时，该场景下性能是有些退化的。cur指向的值与left位置的值进行交换，然后left++，cur++核心思想是把数组中的数据。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

52Hertz_Echo

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

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

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

打赏作者

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

抵扣说明：

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

余额充值