【算法】网络图中的dfs

已于 2024-05-23 16:54:28 修改
阅读量1k 收藏 31
点赞数 36
分类专栏： 算法神殿 文章标签： 算法 深度优先 图论 dfs
于 2024-05-16 07:34:28 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_79188764/article/details/138782179
版权



快乐的流畅：个人主页


个人专栏：《算法神殿》《数据结构世界》《进击的C++》

远方有一堆篝火，在为久候之人燃烧！

文章目录

引言

在二维网络图中的dfs，反而一般不需要画决策树，因为在二维图像中有时候很直观可以看出决策关系，一般为上下左右搜索。

一、单词搜索


细节：

  • dfs函数设置返回值bool，以便及时调整路线
  • 设置向量数组dx，dy
  • 设置bool数组vis，实现剪枝
  • pos设置为函数参数，方便回溯
class Solution
{
    int dx[4] = {1, -1, 0, 0};
    int dy[4] = {0, 0, 1, -1};
    bool vis[7][7];
    int m, n;
public:
    bool dfs(vector<vector<char>>& board, int i, int j, string& word, int pos)
    {
        if(pos == word.size()) return true;

        vis[i][j] = true;
        for(int k=0; k<4; ++k)
        {
            int x = i + dx[k], y = j + dy[k];
            if(x >= 0 && y >= 0 && x < m && y < n 
            && !vis[x][y] && board[x][y] == word[pos])
            {
                if(dfs(board, x, y, word, pos + 1)) return true;
            }
        }
        vis[i][j] = false;
        return false;
    }

    bool exist(vector<vector<char>>& board, string& word)
    {
        m = board.size(), n = board[0].size();
        for(int i=0; i<m; ++i)
        {
            for(int j=0; j<n; ++j)
            {
                if(board[i][j] == word[0])
                {
                    if(dfs(board, i, j, word, 1)) return true;
                }
            }
        }
        return false;
    }
};

二、黄金矿工


细节：

  • 设置向量数组dx，dy
  • 设置bool数组vis，实现剪枝
  • sum设置为函数参数，方便回溯
class Solution
{
    int ret = 0;
    bool vis[16][16];
    int dx[4] = {1, -1, 0, 0};
    int dy[4] = {0, 0, 1, -1};
    int m, n;
public:
    void dfs(vector<vector<int>>& grid, int i, int j, int sum)
    {
        vis[i][j] = true;
        for(int k=0; k<4; ++k)
        {
            int x = i + dx[k], y = j + dy[k];
            if(x >= 0 && y >= 0 && x < m && y < n
            && !vis[x][y] && grid[x][y])
            {
                dfs(grid, x, y, sum + grid[x][y]);
            }
            else ret = max(ret, sum);
        }
        vis[i][j] = false;
    }

    int getMaximumGold(vector<vector<int>>& grid)
    {
        m = grid.size(), n = grid[0].size();
        for(int i=0; i<m; ++i)
        {
            for(int j=0; j<n; ++j)
            {
                if(grid[i][j])
                {
                    dfs(grid, i, j, grid[i][j]);
                }
            }
        }
        return ret;
    }
};

三、不同路径 |||


细节：

  • 设置向量数组dx，dy
  • 设置bool数组vis，实现剪枝
  • path设置为函数参数，方便回溯
class Solution
{
    int ret = 0;
    int dx[4] = {1, -1, 0, 0};
    int dy[4] = {0, 0, 1, -1};
    bool vis[20][20];
    int m, n, count = 0;
public:
    void dfs(vector<vector<int>>& grid, int i, int j, int path)
    {
        if(grid[i][j] == 2)
        {
            if(path + count == m * n) ++ret;
            return;
        }

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

    int uniquePathsIII(vector<vector<int>>& grid)
    {
        m = grid.size(), n = grid[0].size();
        int si, sj;
        for(int i=0; i<m; ++i)
        {
            for(int j=0; j<n; ++j)
            {
                if(grid[i][j] == -1) ++count;
                else if(grid[i][j] == 1) 
                {
                    si = i, sj = j;
                }
            }
        }

        dfs(grid, si, sj, 1);
        return ret;
    }
};
  • 本题开始往后，是floodfill算法的练习
  • floodfill算法，本质就是寻找连通块
  • 同时floodfill算法没有回溯

四、图像渲染



细节：

  • 设置向量数组dx，dy
  • 记录baseColor, newColor
class Solution
{
    int dx[4] = {1, -1, 0, 0};
    int dy[4] = {0, 0, 1, -1};
    int baseColor, newColor;
    int m, n;
public:
    void dfs(vector<vector<int>>& image, int i, int j)
    {
        image[i][j] = newColor;
        for(int k=0; k<4; ++k)
        {
            int x = i + dx[k], y = j + dy[k];
            if(x >= 0 && y >= 0 && x < m && y < n 
            && image[x][y] == baseColor)
            {
                dfs(image, x, y);
            }
        }
    }

    vector<vector<int>> floodFill(vector<vector<int>>& image, int sr, int sc, int color)
    {
        if(image[sr][sc] == color) return image;

        baseColor = image[sr][sc], newColor = color;
        m = image.size(), n = image[0].size();
        dfs(image, sr, sc);
        return image;
    }
};

五、岛屿数量


细节：

  • 设置向量数组dx，dy
  • 设置bool数组vis，实现剪枝
class Solution
{
    int ret;
    bool vis[301][301];
    int dx[4] = {1, -1, 0, 0};
    int dy[4] = {0, 0, 1, -1};
    int m, n;
public:
    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 && y >= 0 && x < m && y < n
            && !vis[x][y] && grid[x][y] == '1')
            {
                dfs(grid, x, y);
            }
        }
    }

    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')
                {
                    dfs(grid, i, j);
                    ++ret;
                }
            }
        }
        return ret;
    }
};

六、岛屿的最大面积



细节：

  • 设置向量数组dx，dy
  • 设置bool数组vis，实现剪枝
class Solution
{
    int ret, sum;
    vector<vector<bool>> vis;
    int dx[4] = {1, -1, 0, 0};
    int dy[4] = {0, 0, 1, -1};
    int m, n;
public:
    void dfs(vector<vector<int>>& grid, int i, int j)
    {
        ++sum;
        vis[i][j] = true;
        for(int k=0; k<4; ++k)
        {
            int x = i + dx[k], y = j + dy[k];
            if(x >= 0 && y >= 0 && x < m && y < n
            && !vis[x][y] && grid[x][y] == 1)
            {
                dfs(grid, x, y);
            }
            else ret = max(ret, sum);
        }
    }

    int maxAreaOfIsland(vector<vector<int>>& grid)
    {
        m = grid.size(), n = grid[0].size();
        vis.resize(m, vector<bool>(n));
        for(int i=0; i<m; ++i)
        {
            for(int j=0; j<n; ++j)
            {
                if(!vis[i][j] && grid[i][j] == 1)
                {
                    sum = 0;
                    dfs(grid, i, j);
                }
            }
        }
        return ret;
    }
};

七、被围绕的区域


细节：

  • 正难则反，将边界上及其相连的‘O’先全部标记起来，最后遍历矩阵，将未被标记的‘O’改成‘X’
  • 设置向量数组dx，dy
  • 设置bool数组vis，实现剪枝
class Solution
{
    vector<vector<bool>> vis;
    int dx[4] = {1, -1, 0, 0};
    int dy[4] = {0, 0, 1, -1};
    int m, n;
public:
    void dfs(vector<vector<char>>& board, 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 && y >= 0 && x < m && y < n
            && !vis[x][y] && board[x][y] == 'O')
            {
                dfs(board, x, y);
            }
        }
    }

    void solve(vector<vector<char>>& board)
    {
        m = board.size(), n = board[0].size();
        vis.resize(m, vector<bool>(n));
        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(!vis[i][j] && board[i][j] == 'O')
                {
                    board[i][j] = 'X';
                }
            }
        }
    }
};

八、太平洋大西洋水流问题




思路：正难则反，水往高处流。

  • 利用两个标记数组，分别记录太平洋和大西洋的水可以流到的区域，找出标记数组重叠的部分即可。
  • 为了只用写一份dfs函数，将vis标记数组以参数的形式传递
  • 设置向量数组dx，dy
class Solution
{
    int dx[4] = {1, -1, 0, 0};
    int dy[4] = {0, 0, 1, -1};
    int m, n;
public:
    void dfs(vector<vector<int>>& heights, 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 && y >= 0 && x < m && y < n
            && !vis[x][y] && heights[x][y] >= heights[i][j])//正难则反，水往高处流
            {
                dfs(heights, x, y, vis);
            }
        }
    }

    vector<vector<int>> pacificAtlantic(vector<vector<int>>& heights)
    {
        m = heights.size(), n = heights[0].size();
        vector<vector<bool>> vis1(m, vector<bool>(n));
        vector<vector<bool>> vis2(m, vector<bool>(n));

        for(int i=0; i<m; ++i)
        {
            if(!vis1[i][0]) dfs(heights, i, 0, vis1);
            if(!vis2[i][n-1]) dfs(heights, i, n-1, vis2);
        }

        for(int j=0; j<n; ++j)
        {
            if(!vis1[0][j]) dfs(heights, 0, j, vis1);
            if(!vis2[m-1][j]) dfs(heights, m-1, j, vis2);
        }

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

九、扫雷游戏



细节：本题实际上是一道模拟题，关键是理解题意。

  • 点击位置是雷，直接改变返回
  • 不是雷，则进入dfs函数递归
  • 对于当前格子，先计算周围8个格子中雷的数量
    • 如果有雷，将当前格子改为雷的数量，返回
    • 如果无雷，将当前格子改为挖出的空方块，继续递归
  • 递归的时候，要进行8个方向的搜索，所以向量数组要存储8个方向
class Solution
{
    bool vis[51][51];
    int dx[8] = {1, 1, 1, 0, 0, -1, -1, -1};
    int dy[8] = {1, 0, -1, 1, -1, 1, 0, -1};
    int m, n;
public:
    void dfs(vector<vector<char>>& board, int i, int j)
    {
        if(board[i][j] == 'M') return;

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

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

    vector<vector<char>> updateBoard(vector<vector<char>>& board, vector<int>& click)
    {
        int ci = click[0], cj = click[1];
        if(board[ci][cj] == 'M')
        {
            board[ci][cj] = 'X';
            return board;
        }

        m = board.size(), n = board[0].size();
        dfs(board, ci, cj);
        return board;
    }
};

总结

网络图中的dfs，常用的搜索技巧，是创建向量数组dx，dy，方便简洁地用循环遍历。


真诚点赞，手有余香

快乐的流畅
关注
  • 36
    点赞
  • 踩
  • 31
    收藏
    觉得还不错? 一键收藏
  • 19
    评论
专栏目录
网络流算法
qq_37957064的博客
03-24 1987
网络流最大流算法 网络流是图论里面最难，也只最有有魅力的分支，事实上图论中很多问题都可以转化为求解最大流的问题，比如说求解最小割的问题，使用网络流算法会使得求解最小割的时间复杂度降低很多，并且网络流算法还具有很大的普适性。 这里我就不多介绍网络流是什么了，相信关于网络流的具体模型，定义有很多科普文章进行了详细的介绍，这里只是给出两种具体的实现算法，以及思想原理。 Edmonds-Krap算法   该算法是一种在网络流残余图上寻找增光路的算法，寻找增广路的过程其实就是DFS或者BFS从源点搜索图都可以，但是关
图算法C语言实现
02-25
图算法，图的性质及类型，图搜索，深度优先搜索，有向图和有向无环图，最小生成树，最短路径，网络流
网络算法-图搜索算法DFS/BFS
weixin_53284122的博客
06-30 704
网络算法-图搜索算法DFS/BFS
从图嵌入算法到图神经网络
luv_dusk 的博客
08-13 1万+
近几年来，伴随着计算机算力的急剧提升，神经网络从历史的尘埃中走出，横扫各大领域，完成一次次颠覆性的创新。依托高度弹性的参数结构，线性与非线性的矩阵变换，神经网络能适用于各式各样的数学场景，在各个类别的应用上我们都能看到神经网络的影子。其中著名的应用方向，包括自然语言处理、计算机视觉、机器学习、生物医疗、推荐系统、自动驾驶等等。图神经网络，广泛应用于社交关系、知识图谱、推荐系统、蛋白质分子建模，同样源自于对传统领域的创新，它的前身是图嵌入算法；而图嵌入算法又以图数据作为载体。这一关系，将贯穿本文始末，成为我们
DFS (深度优先搜索) 算法详解 + 模板 + 例题，这一篇就够了
热门推荐
Layman的博客
04-10 9万+
俗称的“不撞南墙不回头算法”！！！在本篇文章中详细介绍了DFS算法的基本步骤，详解了包括，排列组合问题、n皇后问题、素数问题等DFS的基本例题，后续会不断补充例题！！！
DFS 图遍历路径优化分析
识物专栏
12-29 2万+
深度优先搜索是图的遍历的一种重要方法，在一些网络拓补结构、DNA 网络等复杂图形分析中有很广泛的应用。传统的深度优先搜索，从某一节点开始，依次遍历此节点所有相邻且未被访问的节点，其下一跳节点的选择往往不是最优的。文章通过对当前节点所有未被访问的下一跳节点计算其到所有未访问节点路径总和，选择最优的一个节点作为下一跳节点，使得深度优先搜索在图的遍历过程中总的搜索路径大大减少。 深度优先搜索算法对图的遍历分析 图的遍历是指从图的某个节点开始，沿着某条路径对图中所有节点依次访问。解决图的遍历问题，目前主要.
图搜索算法详解
stormsha
04-22 875
图搜索算法是一种在图数据结构中寻找特定节点或路径的算法。图由节点和边组成，节点表示实体，边表示实体之间的关系。图搜索算法的目标是在图中找到从起始节点到目标节点的最优路径。名称 数据结构 空间复杂度 性质深度优先搜索 DFS 栈 stack O( h ) 其中 h 为树的高度 不具有最短性广度优先搜索 BFD 队列 queue O( 2^h ) 指数级别 具有最短性(总访问最近的点)
网络流算法及知识
qq_56866469的博客
05-19 1972
网络流 : 是指在一个每条边都有容量的有向图分配流，使一条边的流量不会超过它的容量。通常在运筹学中，有向图称为网络。顶点称为节点而边称为弧。一道流必须匹配一个结点的进出的流量相同的限制，除非这是一个源点──有较多向外的流，或是一个汇点──有较多向内的流。一个网络可以用来模拟道路系统的交通量、管中的液体、电路中的电流或类似一些东西在一个结点的网络中游动的任何事物。 算法案例引入 : 然后自来水厂和你家之间修了很多条水管子接在一起 水管子规格不一 有的容量大 有的容量小 然后问自来水厂开闸放水 你家收到水的最大
路径规划 | 图搜索算法：DFS、BFS、GBFS、Dijkstra、A*
白鸟无言的博客
01-25 6529
地图数据常常可以用图(Graph)这类数据结构表示，那么在图结构中常用的搜索算法也可以应用到路径规划中。 本文将从图搜索算法的基本流程入手，层层递进地介绍几种图搜索算法。首先是两种针对无权图的基本图搜索算法：深度优先搜索(Depth First Search, DFS)、广度优先搜索(Breadth First Search, BFS)。它们的区别在于openlist(后面介绍)所选用的数据结构类型不同，前者使用栈，后者使用队列；之后引入一种启发式搜索算法：贪婪最佳优先算法(Greedy Best Firs
数据结构与算法-图论-DFS/BFS
2303_76624483的博客
04-24 1536
我们首先定义一个图结构来表示城市中的路口（节点）和道路（边），然后实现 BFS 搜索找到最短路径。
增广路算法 DFS求解 最大网络流问题
qq_49175846的博客
01-09 644
DFS实现增广路算法 最大网络流问题
数据结构课程设计社交网络图算法及图结构可视化的设计与实现
06-08
在canvas技术支持赋能下，基于图的连接表储存方式，以及基于《数据结构》当中的DFS（深度优先查找）和BFS（广度优先查找）等算法，构建社交网络图算法及图结构等可视化平台。 （1）每个人的信息是一个结点，人与人的...
C#，图论与图算法，寻找图（Graph）中的桥（Bridge）算法与源代码
04-09
C#，图论与图算法，寻找图（Graph）中的桥（Bridge）算法与源代码 如果删除无向连通图中的边会断开该图的连接，则该边就是桥。对于断开连接的无向图，定义类似，桥接是一种边移除，它增加了断开连接的组件的数量。 ...
SubwayStationSearching：使用地图DFS查找地铁网络中的最短路径
02-20
主要算法，读取Stations.py中的地铁图信息并计算最短路径 Stations.py 存储站点信息，目前仅录入了西安市中心的部分站点信息 Station类以存储站点信息 stationMap定义站点间的连接关系 stationStringMap为记录站点名...
C#，图论与图算法，无向图断开点（Articulation Points）的算法与源代码
04-09
C#，图论与图算法，无向图断开点（Articulation Points）的算法与源代码 无向图断开点 如果移除无向连通图中的顶点（以及穿过该顶点的边）会断开该图，则该顶点是一个连接点（或切割顶点Cutting Point）。连接点表示...
【考研数据结构知识点详解及整理——C语言描述】第一章算法和算法评价
qq_63492484的博客
05-21 498
时间复杂度和空间复杂度
双非二本找工作前的准备day28
m0_61724447的博客
05-20 1284
每天复习代码随想录上的题目2-3道算法（时间充足可以继续）
乘法逆元算法
最新发布
2302_81590667的博客
05-22 710
有些云里雾里的那个取正整数的地方，好多地方都是公式推理和验证定理的正确性，看不懂，初等数论再说！乘法逆元的意思就是给出两个数a，b如果a，b互质（就是两个数的最大公约数是1）那么就有。1(mod 5)，x=2,7,12.....x的每个值都差5；可以用费马小定理来推导乘法逆元我就不细讲了想知道可以看这个博客。这个题必须用scanf和printf要不然超时。就是必有a*x%b==1；
【力扣一轮】454.四数之和 && 383.赎金信
诚
05-22 477
为什么能想到这里，注意到它的和是0，（和可以是任何数）这样就相当于两两数组为一对，看其中一对数组中的元素，在另外一对数组中是否出现了相反数。这里的一对说的是A+B或其他组合方式，（不重要，因为都是随机的）然而以上想法截止到第二句，都没问题，需要注意的是，不是全对应。A2：因为在存储时，不仅要存储对应的元素，也要存储元素出现的次数，所以用到map。结合之前的有效字母异位符，数组，set，map，使用数组即可。也就是说如果一对数组中有两个-2，另一对数组中只有一个2，那么计算为0的次数为2。
图 网络与算法.pdf
01-11
《图 网络与算法.pdf》是一本关于图网络与算法的PDF文件。图网络与算法是计算机科学中的一个重要研究领域，该领域研究如何在图结构中进行信息的处理和分析。 图是一种由节点和边构成的数据结构，节点代表实体或对象，边代表节点之间的关系。图网络与算法的主要目标是研究如何从图结构中提取有用的信息，并设计高效的算法来解决与图相关的问题。 在《图 网络与算法.pdf》中，可能包含了以下内容： 1. 图的基本概念：介绍了图的定义、表示方法和基本属性，如节点的度、路径、连通性等。 2. 图算法：介绍了常见的图算法，如广度优先搜索（BFS）、深度优先搜索（DFS）、最短路径算法、最小生成树算法等。这些算法可以应用于图的遍历、路径搜索、优化问题等。 3. 图网络模型：介绍了图网络的基本模型和架构，如图神经网络（Graph Neural Networks，GNN）。图神经网络是专门用于处理图数据的神经网络模型，可以学习节点或边的特征表示，进而用于节点分类、图分类、链接预测等任务。 4. 图网络应用：介绍了图网络在不同领域的应用，如社交网络分析、生物信息学、推荐系统等。这些应用展示了图网络与算法在实际问题中的价值和应用前景。 总之，阅读《图 网络与算法.pdf》可以帮助读者了解图网络与算法的基本原理、常用算法和应用场景，对于从事计算机科学、数据科学以及相关领域的研究人员或学生来说，这本书是一份有价值的参考资料。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值