深度优先搜索（Depth First Search）

最新推荐文章于 2024-06-18 09:27:23 发布
最新推荐文章于 2024-06-18 09:27:23 发布
阅读量491 收藏
点赞数
分类专栏： 牛客网&&LeetCode中好的题 深度优先搜索 文章标签： 算法 1024程序员节
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/MEANSWER/article/details/120798379
版权

深度优先搜索


遍历每一个点都是一条道走到黑才停止下来，所以也被称为深度优先搜索

1. LeetCode690题—员工的重要性

链接: https://leetcode-cn.com/problems/employee-importance/
在这里插入图片描述
题解：这道题的关键在于问题的最后说的是“这个员工和他所有下属的重要度之和”，当拿到第一个直系下属的id的时候，加上他的重要度，然后再去求直系下属的下属，所以这里是有点像二叉树的前序遍历的，先要一条道走到无路可走的时候，在考虑返回的问题

class Solution {
public:
    void dfs(unordered_map<int,Employee*>& idmap,int& sum,int id)
    {
        sum += idmap[id]->importance;
        for(auto& subid: idmap[id]->subordinates)
        {
            dfs(idmap,sum,subid);
        }
    }
    //从题目可以看到，她最后问的是返回所有下属的重要度之和
    int getImportance(vector<Employee*> employees, int id) {
        //我希望能够通过id可以直接的找到这个员工的所有信息
        unordered_map<int,Employee*> Idmap;
        for(auto& e : employees)
        {
            Idmap[e->id] = e;
        }
        //上面就很好的把id和对应的员工信息进行了绑定
        int sum = 0;
        dfs(Idmap,sum,id);
        return sum;
    }
};

2. LeetCode733题—图像渲染

链接: https://leetcode-cn.com/problems/flood-fill/
在这里插入图片描述
题解：
对于这道题需要一个辅助数组，这个数组用来记录每个点是否有被访问过。

  1. 第一步就是修改题目中所要渲染的点
  2. 然后以这个点为中心去向他的前后左右4个方向寻找合法的点（判断边界）
  3. 如果找到了，那就判断是否和原来颜色相同，且没有被访问过
  4. 以该点为中心在重复上面的步骤
int nextposition[4][2] = {{-1,0},{1,0},{0,-1},{0,1}};
class Solution {
public:
    void DFS(vector<vector<int>>& image,vector<vector<int>>& visited,int row,int col,int sr,int sc,int oldColor,int newColor)
    {
        //第一步就是修改我们所给的坐标
        image[sr][sc] = newColor;
        visited[sr][sc] = 1; //表示这个位置被遍历过了
        //第二部就是以这个新改的点为中心开始上下左右去搜索是否那些位置符合（且要进行边界的判断）
        for(int i = 0;i<4;++i)
        {
            //这里也就算出来了每一个发散出来的4个方向新的坐标
            int newx = sr + nextposition[i][0];
            int newy = sc + nextposition[i][1];
            //判断有效性
            //如果不满足条件，那就不需要进行下面的步骤，直接计算下一个新的点
            if(newx <0 || newx >= row || newy < 0 || newy >= col)
                continue;
            //走到这里就说明他是具有合法性的
            if(image[newx][newy] == oldColor && visited[newx][newy] == 0)
            {
                DFS(image,visited,row,col,newx,newy,oldColor,newColor);
            }
        }
    }
    vector<vector<int>> floodFill(vector<vector<int>>& image, int sr, int sc, int newColor) {
        int row = image.size();
        int col = image[0].size();
        vector<vector<int>> visited(row,vector<int>(col,0));//表示每一个位置都是没有被访问过的
        int oldColor = image[sr][sc];
        DFS(image,visited,row,col,sr,sc,oldColor,newColor);
        return image;
    }
};

2.1. LeetCode463题—岛屿的周长

链接: https://leetcode-cn.com/problems/island-perimeter/
在这里插入图片描述
解题思路：
对于一个陆地格子的每条边，它被算作岛屿的周长当且仅当这条边为网格的边界或者相邻的另一个格子为水域。 因此，我们可以遍历每个陆地格子，看其四个方向是否为边界或者水域，如果是，将这条边的贡献1

class Solution {
public:
    int dfs(vector<vector<int>>& grid,int i,int j,int row,int col)
    {
        if(i < 0 || i >= row || j < 0 || j >= col)
            return 1;
        if(grid[i][j] == 0)
            return 1;
        if(grid[i][j] == 2)
            return 0;
        grid[i][j] = 2; //表示该点已经访问过了
        //要的是前后左右所提供的贡献
        return dfs(grid,i-1,j,row,col) + dfs(grid,i,j-1,row,col) + dfs(grid,i+1,j,row,col) + dfs(grid,i,j+1,row,col);
    }
    int islandPerimeter(vector<vector<int>>& grid) {
        int row = grid.size();
        int col = grid[0].size();
        int sum = 0;
        for(int i = 0;i<row;i++)
        {
            for(int j = 0;j<col;j++)
            {
                //遍历整个二维地图，如果找到陆地，就进行接下来的操作
                if(grid[i][j] == 1)
                {
//这个dfs相当于算出来当前这个陆地他的四个方向上所能给他周长的贡献,然后遍历每一块陆地都算出来的累加和，就是周长
                    sum += dfs(grid,i,j,row,col); 
                }
            }
        }
        return sum;
    }
};

解法2：迭代法好像更加能够使人理解(这到题强烈推荐方法)

int nextposition[4][2] = {{-1,0},{1,0},{0,-1},{0,1}};
class Solution {
public:
    //这道题用迭代的方法好像就会好很多
    //但是迭代就不怕算已经遍历过的吗？
    int islandPerimeter(vector<vector<int>>& grid) {
        int row = grid.size();
        int col = grid[0].size();
        int sum = 0;
        for(int i = 0;i<row;++i)
        {
            for(int j = 0;j<col;++j)
            {
                if(grid[i][j] == 1)
                {
                    int ret = 0;
                    for(int k = 0;k<4;++k)
                    {
                        int x = i + nextposition[k][0];
                        int y = j + nextposition[k][1];
                        if(x <0 || x>=row || y < 0 || y>= col || grid[x][y] == 0)
                            ret += 1;
                    }
                    sum += ret;
                }
            }
        }
        return sum;
    }
};

2.2 LeetCode200题—岛屿数量

链接: https://leetcode-cn.com/problems/number-of-islands/
在这里插入图片描述
题解：这道题和渲染的思想如出一辙，基本一致(只是这里并不需要修改连接在一起的点颜色)

int nextposition[4][2] = {{-1,0},{1,0},{0,-1},{0,1}};
class Solution {
public:
    void dfs(vector<vector<char>>& grid,vector<vector<int>>& visited,int row,int col,int i,int j)
    {
        //以第一个示例为例子，在这里进行解说,等这里都走完了之后，就会发现将所有连在一起的'1'都进行了渲染
        visited[i][j] = 1;
        for(int k = 0;k<4;++k)
        {
            int x = i + nextposition[k][0];
            int y = j + nextposition[k][1];
            if(x < 0 || x >= row || y < 0 || y >= col)
                continue;
            if(grid[x][y] == '1' && visited[x][y] == 0)
            {
                dfs(grid,visited,row,col,x,y);
            }
        }
    }
    int numIslands(vector<vector<char>>& grid) {
        int row = grid.size();
        int col = grid[0].size();
        //初始化0表示所有的点都没有拜访过，1则表示这个点已经访问过了
        vector<vector<int>> visited(row,vector<int>(col,0));
        int num = 0;
        for(int i = 0;i<row;++i)
        {
            for(int j = 0;j<col;++j)
            {
                if(grid[i][j] == '1' && visited[i][j] == 0)
                {
                    num++;
                    dfs(grid,visited,row,col,i,j);
                }
            }
        }
        return num;
    }
};

2.3 LeetCode695题—岛屿的最大面积

链接: https://leetcode-cn.com/problems/max-area-of-island/
在这里插入图片描述
题解：同样的思想，相当于找到岛屿的数量题

int nextposition[4][2] = {{-1,0},{1,0},{0,-1},{0,1}};
class Solution {
public:
    void dfs(vector<vector<int>>& grid,vector<vector<int>>& visited,int row,int col,int i,int j,int& sum)
    {
        sum += 1;
        visited[i][j] = 1;
        for(int k = 0;k<4;++k)
        {
            int x = i + nextposition[k][0];
            int y = j + nextposition[k][1];
            if(x < 0 || x >= row || y < 0 || y >= col)
                continue;
            if(grid[x][y] == 1 && visited[x][y] == 0)
            {
                dfs(grid,visited,row,col,x,y,sum);
            }
        }
    }
    int maxAreaOfIsland(vector<vector<int>>& grid) {
        int row = grid.size();
        int col = grid[0].size();
        vector<vector<int>> visited(row,vector<int>(col,0));
        int max = 0;
        for(int i = 0;i<row;++i)
        {
            for(int j = 0;j<col;++j)
            {
                if(grid[i][j] == 1 && visited[i][j] == 0)
                {
                    int sum = 0;
                    dfs(grid,visited,row,col,i,j,sum);
                    max = std::max(max,sum);
                }
            }
        }
        return max;
    }
};

3. LeetCode130题—被围绕的区域

链接: https://leetcode-cn.com/problems/surrounded-regions/
在这里插入图片描述
题解：可以从相反的思路下手，我们想要找完全被‘X’包围的’O’,但是会发现并不好找，那么我们就找没有被’X’完全包围的’O’,边界上的’O’一定没有被’X’完全包围，那么和边界上的这个’O’相连的‘O’肯定都不满足

int nextposition[4][2] = {{-1,0},{1,0},{0,-1},{0,1}};
class Solution {
public:
    //必须是4个方向都包围的（完全封闭的），才能算作是被包围的，才能够替换
    //这道题的解法优点向图像渲染，只不过这道题需要首先是从反方向思考下手
    //我去找那些完全被X包围的o是不好找的，但是我去找边上的o，以及和他相连的o那么这些o就是都不能够被替换的，只需要在这个过程中做好特殊标记就型
    void dfs(vector<vector<char>>& board,int i,int j,int row,int col)
    {
        board[i][j] = '*';
        for(int k = 0;k<4;++k)
        {
            int x=  i + nextposition[k][0];
            int y = j + nextposition[k][1];
            if(x <0 || x>= row || y < 0 || y>= col)
                continue;
            //走到这里说明是合法的点，那么就要判断这个点是都也是'O' 且没有被渲染过
            if(board[x][y] == 'O' && board[x][y] != '*')
                dfs(board,x,y,row,col);
        }
    }
    void solve(vector<vector<char>>& board) {
        int row = board.size();
        int col = board[0].size();
        //找第一行和最后一行中的'0'
        for(int j = 0;j<col;++j)
        {
            if(board[0][j] == 'O')
                dfs(board,0,j,row,col);
            if(board[row-1][j] == 'O')
                dfs(board,row-1,j,row,col);
        }
        //找第一列和最后一列中的'O'
        for(int i = 0;i<row;++i)
        {
            if(board[i][0] == 'O')
                dfs(board,i,0,row,col);
            if(board[i][col-1] == 'O')
                dfs(board,i,col-1,row,col);
        }

        //上面也就把所有没有被X完全包围的'O'都修改为了'*'
        for(int i = 0;i<row;i++)
        {
            for(int j = 0;j<col;j++)
            {
                //此时的'O'是完全被包围的
                if(board[i][j] == 'O')
                    board[i][j] = 'X';
                if(board[i][j] == '*')
                    board[i][j] = 'O';
            }
        }
    }
};

4. 剑指offer13题—机器人的运动范围

链接:https://leetcode-cn.com/problems/ji-qi-ren-de-yun-dong-fan-wei-lcof/在这里插入图片描述

class Solution {
public:
    int get(int x)
    {
        int ret = 0;
        while(x)
        {
            ret += (x % 10);
            x /= 10;
        }
        return ret;
    }
    void  DFS(int i,int j,int m,int n,int k,int& count,vector<vector<int>>& visited)
    {
        if(i < 0 || i>= m || j < 0 || j >= n || get(i) + get(j) > k || visited[i][j] == 1)
            return;
        count++;
        visited[i][j] = 1;
        //然后再处理他的四个方向
        DFS(i+1,j,m,n,k,count,visited);
        DFS(i-1,j,m,n,k,count,visited);
        DFS(i,j-1,m,n,k,count,visited); 
        DFS(i,j+1,m,n,k,count,visited); 
    }
    //这道题可以理解为他能满足的走的格子
    int movingCount(int m, int n, int k) {
        vector<vector<int>> visited(m,vector<int>(n,0));
        int count = 0;
        DFS(0,0,m,n,k,count,visited);
        return count;
    }
};
没什么..
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
算法--深度优先搜索depth first search
10-05
将《linux_C一站式编程》一书中的深度优先算法解决迷宫问题中的代码较难理解部分标注并解释，附有该节课后习题的代码,包括： 1.从起点到终点正向打印迷宫路线 2.predecessor这个数据结构占用的存储空间太多，将原...
深度优先搜索
DeepStarSky的博客
10-11 1万+
深度优先搜索 一.什么是深度优先搜索 深度优先搜索，Depth First Search, 简称DFS。它从初始节点出发，按预定的顺序扩展到下一个节点，然后从下一节点出发继续扩展新的节点，不断递归执行这个过程，直到某个节点不能再扩展下一个节点为止。此时，则返回上一个节点重新寻找一个新的扩展节点。如此搜索下去，直到找到目标节点，或者搜索完所有节点为止。 如果从位置开始深度优先搜索，则搜索的顺序为： 1→2→3→5→9→10→6→11→12→7→4→81 \to 2 \to 3 \to 5 \to 9 \to
深度优先搜索详解
panpanpan17452的博客
10-10 5731
深度优先搜索详解
【数据结构与算法】深度优先搜索（DFS）
最新发布
DreamSuif的博客
06-18 836
对于考研人来说，BFS和DFS指的是图的两种遍历算法。但是严格意义上说，BFS和DFS是两种搜索策略。BFS代表算法在执行时，会像树的层次遍历那样，从属于同一个结点的后继的访问顺序相邻。DFS代表算法在执行时，会像树的先序遍历那样，沿着某条路径走到终点，再返回走另外一条路径。
深度优先搜索（DFS）（算法笔记）
Arabot_的博客
03-22 8506
深度优先搜索是一种枚举所有完整路径以遍历所有情况的搜索方法，总是以“深度”作为前进的关键词。实现方式是有很多，最常见的是递归。深度优先搜索属于搜索问题的一种，当问题可以被描述为“路径搜索”时，就可以采用搜素问题的所有解的方式来进行解决，所以DFS本质还是暴力。深度搜索具有两个关键词，即“岔道口”和“死胡同”，这两个词来源于迷宫问题，这也是搜索问题最原始的表现。当碰到岔道口时，总是以“深度”作为前进的关键词，不碰到死胡同就不回头，因此被称为“深搜”。
算法详解之深度优先搜索算法
热门推荐
LQ的博客
10-28 2万+
深度优先搜索算法
DFS深度优先搜索
咸鱼势力登场
06-28 1万+
一、DFS的概念 {DFS的定义 DFS的搜索方式 DFS采用的数据结构 DFS的特点} 二、DFS的实战应用 {1.排列数字 2.n-皇后问题}
PHP实现深度优先搜索算法(DFS,Depth First Search)详解
10-19
深度优先搜索（DFS, Depth First Search）是一种在图或树数据结构中进行遍历或搜索的算法。它的基本思想是从给定的起始节点开始，尽可能深地探索节点的子树，直到达到叶子节点或者回溯到没有未访问过的邻接节点为止...
深度优先搜索（Depth-First Search, DFS）.zip
04-10
深度优先搜索（DFS，Depth-First Search）是一种用于遍历或搜索树或图的算法，其基本思想是从起点开始，沿着某一条路径一直探索到尽可能深的层次，如果这条路径到达了叶子节点或者遇到死胡同，就回溯到上一个节点，...
C++ 算法篇 深度优先搜索（DFS）
流年的博客
01-28 1万+
图的遍历 图的遍历为从图中某一顶点出发访遍图中其余顶点，且使每一个顶点仅被访问一次的过程。 对于图的遍历，不想树那么简单，需要在遍历的过程中把访问过的顶点打上标记，以避免访问多次。具体办法是设置一个访问数组visited[n]，n是图中顶点的个数，初始值为0，访问后设置为1。 对于图的遍历来说，通常有两种遍历方案：深度优先遍历和广度优先遍历。 深度优先遍历 深度优先遍历（Depth_Fi...
【Python搜索算法】深度优先搜索（DFS）算法原理详解与应用，示例+代码
qq_35831906的博客
10-16 1万+
深度优先搜索（DFS）是一种重要的图遍历算法，用于探索图中的节点和边。本节介绍DFS算法原理和DFS算法应用案例：解决路径查找问题，解决图的连通性问题：查找下图中的连通组件，拓扑排序，在树结构中进行深度遍历
基础-深度优先搜索（DFS）
Ice_teapoy的博客
02-19 2023
1 深度优先搜索（DFS） 1.1 定义 先说什么是搜索。搜索算法是利用计算机的高性能来有目的的穷举一个问题解空间的部分或所有的可能情况，从而求出问题的解的一种方法。在忽略效率的情况下，没有什么是搜索解决不了的（？ 深度优先搜索（DFS）是基于递归的搜索。 想象你在走迷宫： 1、 这个方向有路可走，我没走过 2、 往这个方向前进 3、 是死胡同（到达了已经走过的地方），往回走，回到上一个路口 4、 重复第一步，直到找着出口 通过这种方式，只要地点的数量是有限的，你就一定可以在有限的时间找到迷宫的出口（或者确
深度优先搜索（DFS）
m0_68805093的博客
08-11 1050
深度优先搜索（Depth-First Search，DFS）是一种常见的图遍历算法，用于在图或树等数据结构中探索所有可能的路径，以及查找特定目标（如寻找路径、判断连通性等）。DFS从一个起始顶点出发，沿着一条路径尽可能深入地访问顶点，直到不能继续为止，然后回溯到之前的顶点，继续尝试其他路径。这个过程通常使用递归来实现。在图的DFS中，我们需要记录已经访问过的顶点，以避免无限循环。从起始顶点开始，对于每个未访问的邻接顶点，我们递归地执行DFS。下图为一个示例图，我们将对这个图进行DFS遍历。
算法数据结构——图的遍历之深度优先搜索算法（Depth First Search）
白话机器学习
06-06 9414
深度优先搜索算法（Depth First Search）：英文缩写为 DFS。是一种用于搜索树或图的算法。所谓深度优先，就是说每次都尝试向更深的节点走。深度优先搜索采用了回溯思想，该算法沿着树的深度遍历树的节点，会尽可能深的搜索树的分支。当节点v的所在边都己被探寻过，搜索将回溯到发现节点v的那条边的起始节点。这一过程一直进行到已发现从源节点可达的所有节点为止。如果还存在未被发现的节点，则选择其中一个作为源节点并重复以上过程，整个进程反复进行直到所有节点都被访问为止。
数据结构与算法(三) 深度优先搜索
半虹小站
11-05 2243
本篇文章首先来学习深度优先搜索算法（Depth-First-Search，DFS）
DFS（深度优先搜索）详解（概念讲解，图片辅助，例题解释，剪枝技巧）
aliyonghang的博客
01-25 7289
深度优先搜索作为初学者遇到的第一个算法，给大家留下了许多“美好”的回忆。不说废话，先来看看百度百科是怎么说的。深度优先搜索是一种在开发爬虫早期使用较多的方法。它的目的是要达到被搜索结构的叶结点(即那些不包含任何超链的HTML文件在一个HTML文件中，当一个超链被选择后，被链接的HTML文件将执行深度优先搜索，即在搜索其余的超链结果之前必须先完整地搜索单独的一条链。深度优先搜索沿着HTML文件上的超链走到不能再深入为止，然后返回到某一个HTML文件，再继续选择该HTML文件中的其他超链。当不再有其他超链。
Python实现深度优先遍历（DFS）和广度优先遍历（BFS）
西门一刀的博客
11-23 1万+
一，简介 深度优先遍历(Depth First Search, 简称 DFS) 与广度优先遍历(Breath First Search)是图论中两种非常重要的算法，生产上广泛用于拓扑排序，寻路(走迷宫)，搜索引擎，爬虫等，也频繁出现在 leetcode，高频面试题中。 二，深度优先遍历 主要思路是从图中一个未访问的顶点 V 开始，沿着一条路一直走到底，然后从这条路尽头的节点回退到上一个节点，再从另一条路开始走到底…，不断递归重复此过程，直到所有的顶点都遍历完成，它的特点是不撞南墙不回头，先走完一条路，再换一
depth first search
03-16
深度优先搜索（Depth First Search）是一种图形搜索算法，它从根节点开始遍历图，尽可能深地搜索每个可能的分支，直到找到目标节点或到达叶子节点。它使用栈来实现，每次将当前节点的所有未访问过的邻居节点压入栈中...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值