leetcode之深度优先搜索刷题总结3

已于 2022-02-10 16:33:59 修改
阅读量638 收藏
点赞数
分类专栏： 算法与数据结构 文章标签： 深度优先 leetcode 算法
于 2022-02-10 15:44:52 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/nuist_NJUPT/article/details/122838265
版权

leetcode之深度优先搜索刷题总结3

1-找到最终的安全状态
题目链接：题目链接戳这里！！！

思路：dfs+三色标记法
根据题意，若起始节点位于一个环内，或者能到达一个环，则该节点不是安全的。否则，该节点是安全的。

我们可以使用深度优先搜索来找环，并在深度优先搜索时，用三种颜色对节点进行标记，标记的规则如下：
白色（用 0 表示）：该节点尚未被访问；
灰色（用 1 表示）：该节点位于递归栈中，或者在某个环上；
黑色（用 2 表示）：该节点搜索完毕，是一个安全节点。

如果搜索过程中出现不安全的，即color>0且color=1的，则返回false。如果都是安全的，则标记为color=2

class Solution {
    public List<Integer> eventualSafeNodes(int[][] graph) {
        List<Integer> list = new ArrayList<>() ;
        int [] color = new int [graph.length];
        for(int i=0; i<graph.length; i++){
            if(dfs(graph,color,i)){
                list.add(i) ;
            }
        }
        return list ;
    }
    public boolean dfs(int [][]graph, int []color, int i){
        if(color[i]>0){
            return color[i]==2 ;
        }

        color[i] = 1 ;
        for(int j : graph[i]){
            if(!dfs(graph,color,j)){
                return false ;
            }
        } 
        color[i] = 2 ;
        return true ;
        
    }
}

在这里插入图片描述
2-网络延迟时间
题目链接：题目链接戳这里！！！

思路：题目实际是求节点 K 到其他所有点中最远的距离，那么首先需要求出节点 K 到其他所有点的最短路，然后取最大值即可。
单源最短路径问题，我们使用Dijkstra算法。

首先，Dijkstra 算法需要存储各个边权，所以代码中使用了邻接矩阵 g[i][j] 存储从点 i 到点 j 的距离。若两点之间没有给出有向边，则初始化为 inf。

算法还需要记录所有点到源点的最短距离，代码中使用了 dist[i] 数组存储源点到点 i 的最短距离，初始值也全部设为 inf。由于本题源点为 K，所以该点距离设为 0。

其次，Dijkstra 算法需要标记某一节点是否已确定了最短路，在代码中使用了vis[i] 数组存储，若已确定最短距离，则值为 true，否则值为 false。

算法需要从当前全部未确定最短路的点中，找到距离源点最短的点，通过该点更新其他所有点距离源点的最短距离。

之所以 inf 设置为 Integer.MAX_VALUE / 2 ，是因为在更新最短距离的时候，要有两个距离相加，为了防止溢出 int 型，所以除以 2。

class Solution {
   public int networkDelayTime(int[][] times, int n, int k) {
       int INF = Integer.MAX_VALUE / 2 ;
       int [][]g = new int [n][n] ;
       for(int i=0; i<n; i++){
           Arrays.fill(g[i],INF) ;
       }
       for(int [] t : times){ //数组g存储边的权值
         g[t[0]-1][t[1]-1] = t[2] ; 
       }
       int [] dist = new int [n] ; //记录源点到目标节点的最短距离
       Arrays.fill(dist,INF) ;
       dist[k-1] = 0 ;

       boolean [] vis = new boolean[n] ; //记录当前节点是否已经确定为最短路径

       for(int i=0; i<n; i++){
            int x = -1 ;
           for(int y=0; y<n; y++){
               if(!vis[y] &&(x==-1 || dist[y]<dist[x])){
                   x = y ;
               }
           }
           vis[x] = true ;
           for(int y=0; y<n; y++){
               dist[y] = Math.min(dist[y],dist[x]+g[x][y]) ;
           }
       }
       int res = Integer.MIN_VALUE ;
       for(int value : dist){
           res = Math.max(value,res) ;
       }

       return res == INF ? -1 : res ;

    }
}

在这里插入图片描述
3-跳跃游戏III
题目链接：题目链接戳这里！！！

思路：记忆化搜索，每次可以向两个方向搜索，如果搜索重复位置，则中止当前搜索，如果搜索的当前值为0，则标记可以跳到，即flag=true。

AC代码如下：

class Solution {
   boolean flag ;
    public boolean canReach(int[] arr, int start) {
        //记忆化搜索
        boolean [] vis = new boolean [arr.length] ;
        flag = false ;
        dfs(arr, start,  vis);
        return flag;
    }
    public void dfs(int []arr, int start, boolean [] vis){
    
        if(arr[start]==0){
            flag=true ;
            return ;
        }
        if(vis[start]){
            return ;
        }

        vis[start] = true ;
        if(start+arr[start]<=arr.length-1){
            dfs(arr,start+arr[start],vis) ;
        }
        if(start-arr[start]>=0){
            dfs(arr,start-arr[start],vis) ;
        }

    }

}

在这里插入图片描述
4-找到所有的农场组
题目链接：题目链接戳这里！！！

思路：搜索+标记，每一轮搜索到的连通块，更新下标的最大值，即是右下角。每一次将第一次搜索的下标和右下角的下标分别存入结果集合中，如果当前下标就是右下标，则直接返回当前下标。

class Solution {
    int [] dx = {0,0,-1,1} ;
    int [] dy = {1,-1,0,0} ;
    int maxX , maxY  ;
    List<Integer> list = new ArrayList<>() ;
    public int[][] findFarmland(int[][] land) {
     
        for(int i=0; i<land.length; i++){
            for(int j=0; j<land[0].length; j++){
                if(land[i][j]==1){
                    maxX = Integer.MIN_VALUE ;
                    maxY = Integer.MIN_VALUE ;
                    list.add(i) ;
                    list.add(j) ;
                   dfs(land,i,j) ;
                   if(maxX!=Integer.MIN_VALUE){
                    list.add(maxX) ;
                   }else{
                       list.add(i) ;
                   }
                   if(maxY!=Integer.MIN_VALUE){
                    list.add(maxY) ;
                   }else{
                       list.add(j) ;
                   }
                }
            }
        }
        int [][] ans = new int [list.size()/4][4] ;
        int k = 0 ;
        for(int i=0;i<ans.length; i++){
            for(int j=0; j<ans[0].length; j++){
                ans[i][j] = list.get(k) ;
                k ++ ;
            }
        }
        return ans ;
    }
    public void dfs(int [][] land, int x, int y){
        land[x][y] = 0 ;
        for(int i=0; i<4; i++){
            int tx = x + dx[i] ;
            int ty = y + dy[i] ;
            if(tx<0 || ty<0 || tx>land.length-1 || ty>land[0].length-1){
                continue ;
            }
            if(land[tx][ty]==1){
                maxX = Math.max(maxX, tx) ;
                maxY = Math.max(maxY, ty) ;
                dfs(land, tx, ty) ;
            }
        }
    }
}

在这里插入图片描述
5-传递信息
题目链接：题目链接戳这里！！！

思路：将二维关系数组转换成有向图，从原始位置开始搜索，每次搜索step+1，如果搜索k次后，当前的编号为n-1，表示经过 k 轮传递到编号为 n-1 的小伙伴处，则ways++。

class Solution {
    int ways;
    List<List<Integer>> edges;

    public int numWays(int n, int[][] relation, int k) {
        ways = 0;
        edges = new ArrayList<List<Integer>>();
        for (int i = 0; i < n; i++) {
            edges.add(new ArrayList<Integer>());
        }
        for (int[] edge : relation) {
            edges.get(edge[0]).add(edge[1]);
        }
        dfs(0, 0,n,k);
        return ways;
    }

    public void dfs(int index, int steps,int n, int k) {
        if (steps == k) {
            if (index == n - 1) {
                ways++;
            }
            return;
        }
        List<Integer> list = edges.get(index);
        for (int nextIndex : list) {
            dfs(nextIndex, steps + 1, n, k);
        }
    }
}

思路：动态规划
dp[k][n-1]表示经过 k 轮传递到编号为 n-1 的小伙伴处的方案数
递推表达式：dp[i+1][edge[1]] += dp[i][edge[0]] ;

class Solution {
    public int numWays(int n, int[][] relation, int k) {
     int [][] dp = new int [k+1][n] ;
     dp[0][0] = 1 ;
     for(int i=0; i<k; i++){
         for(int [] edge : relation){
             dp[i+1][edge[1]] += dp[i][edge[0]] ;
         }
     }
     return dp[k][n-1] ;

    }
}

在这里插入图片描述

6-省份数量
题目链接：题目链接戳这里！！！

思路：判断每个省份是否已经搜索，若没搜索，则进行搜索，每轮搜索进行标记为已搜索，每轮搜索累加省份数量，直至搜索完成。

class Solution {
    boolean [] vis ;
    public int findCircleNum(int[][] isConnected) {
        int povince = isConnected.length ;
        int cnt = 0 ;
        vis = new boolean[povince] ;
        for(int i=0; i<povince; i++){
            if(!vis[i]){
                dfs(isConnected,i,vis,povince) ;
                cnt ++ ;
            }
        }
        return cnt ;
    }
    public void dfs(int [][] isConnected, int i, boolean[] vis, int povince){

        vis[i] = true ;
        for(int j=0; j<povince; j++){
            if(isConnected[i][j]==1 && !vis[j]){
                dfs(isConnected,j,vis,povince) ;
            }
        }

    }
}

在这里插入图片描述

7-机器人的运动范围
题目链接：题目链接戳这里！！！

思路：沿着四个方向进行搜索，如果如果当前位置满足搜索条件，就累加1，继续搜索下去，直至不能搜索。

class Solution {
    int [] dx = {0,0,-1,1} ;
    int [] dy = {-1,1,0,0} ;
    int cnt ;
    boolean [][] vis ;
    public int movingCount(int m, int n, int k) {
        cnt = 0 ;
        vis = new boolean[m][n] ;
        dfs(0,0,m,n,k,vis) ;
        return cnt ;
    }
    public void dfs(int i, int j, int m, int n, int k, boolean[][] vis){
        vis[i][j] = true ;
        cnt ++ ;
        for(int x=0; x<4; x++){
            int tx = i + dx[x] ;
            int ty = j + dy[x] ;
            if(tx<0 || ty<0 || tx>m-1 || ty>n-1 || sum(tx,ty)>k){
                continue ;
            }
            if(!vis[tx][ty]){
                dfs(tx,ty,m,n,k,vis) ;
            }
        }
    }
    public int sum (int tx, int ty){
        int res = 0 ;
        String s1 = String.valueOf(tx) ;
        String s2 = String.valueOf(ty) ;
        for(int i=0; i<s1.length(); i++){
            res += (s1.charAt(i)-'0') ;
        }
        for(int i=0; i<s2.length(); i++){
            res += (s2.charAt(i)-'0') ;
        }
        return res ;

    }
}

在这里插入图片描述

8-水域大小
题目链接：题目链接戳这里！！！

思路：沿着8个方向搜索，每轮搜索记录水域大小，最后对水域大小进行升序排序即可。

class Solution {
    int cnt ;
    int [] dx = {-1,-1,-1,0,0,1,1,1} ;
    int [] dy = {-1,0,1,-1,1,-1,0,1} ;
    public int[] pondSizes(int[][] land) {
        List<Integer> list = new ArrayList<>() ;
        for(int i=0; i<land.length; i++){
            for(int j=0; j<land[0].length; j++){
                if(land[i][j]==0){
                    cnt = 0 ;
                    dfs(land,i,j) ;
                    list.add(cnt) ;
                }
            }
        }
        int [] res = new int [list.size()] ;
        int j = 0 ;
        for(int value : list){
            res[j++] = value ;
        }
        Arrays.sort(res) ;
        return res ;
    }
    public void dfs(int [][] land, int x, int y){
        land[x][y]=1 ;
        cnt ++ ;
        for(int i=0;i<8; i++){
            int tx = x + dx[i] ;
            int ty = y + dy[i] ;
            if(tx<0 || ty<0 || tx>land.length-1 || ty>land[0].length-1){
                continue ;
            }
            if(land[tx][ty]==0){
                dfs(land,tx,ty) ;
            }

        }

    }
}

在这里插入图片描述

9-岛屿的最大面积
题目链接：题目链接戳这里！！！

思路：沿着四个方向搜索，每轮搜索对比岛屿面积，找出最大的岛屿面积即可。

class Solution {
    int cnt ;
    int [] dx = {-1,1,0,0} ;
    int [] dy = {0,0,-1,1} ;
    public int maxAreaOfIsland(int[][] grid) {
        int max = 0 ;
        for(int i=0; i<grid.length; i++){
            for(int j=0; j<grid[0].length; j++){
                if(grid[i][j]==1){
                    cnt = 0 ;
                    dfs(grid,i,j) ;
                    max = Math.max(max,cnt) ;
                }
            }
        }
        return max ;
    }
    public void dfs(int [][]grid, int x, int y){
        grid[x][y] = 0 ;
        cnt ++ ;
        for(int i=0;  i<4; i++){
            int tx = x + dx[i] ;
            int ty = y + dy[i] ;
            if(tx<0 || ty<0 || tx>grid.length-1 || ty>grid[0].length-1){
                continue ;
            }
            if(grid[tx][ty]==1){
                dfs(grid,tx,ty) ;
            }
        }
    }
}

在这里插入图片描述

10-课程顺序
题目链接：题目链接戳这里！！！

思路：将课程表转换成有向图，对有向图进行搜索，如果有环，则说明无法学完所有课程，否则可以学完所有课程。

vis数组是标记数组。
vis为0时，代表尚未学习该课程
vis为1时，代表此轮搜索中已学习过该课程，代表有环
vis为-1时，代表上轮搜索中学习了该课程，无环。

class Solution {
    List<List<Integer>> edges ;
    List<Integer>res = new ArrayList<>() ;
    public int[] findOrder(int numCourses, int[][] prerequisites) {
        edges = new ArrayList<>() ;
        int [] vis = new int [numCourses] ;
        for(int i=0; i<numCourses; i++){
            edges.add(new ArrayList<>()) ;
        }
        for(int []edge : prerequisites){
            edges.get(edge[1]).add(edge[0]) ;
        }
        for(int i=0; i<numCourses; i++){
            if(!dfs(edges,i,vis)){
                return new int []{} ;
            }
        }
        int [] arr = new int [res.size()] ;
        int j = 0 ;
        for(int i=0; i<arr.length; i++){
            arr[j++] = res.get(arr.length-i-1) ;
        }
        return arr;
    }
    public boolean dfs(List<List<Integer>> edges, int i, int [] vis){
        if(vis[i]==1){
            return false ;
        }
        if(vis[i]==-1){
            return true ;
        }
        vis[i] = 1 ;
      
        for(int j : edges.get(i)){
            if(!dfs(edges,j,vis)){
                return false ;
            }
        }
        vis[i] = -1 ;
         res.add(i) ;
        return true ;
    }
}

在这里插入图片描述

nuist__NJUPT
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
leetcode--深度优先（DFS）概念总结和经典题目解析汇总
数据挖掘+大数据研发+算法学习
12-31 1067
ing
【Leetcode刷题】深度优先搜索
最新发布
m0_51976564的博客
04-02 355
Leetcode104.二叉树的最大深度 Leetcode111.二叉树的最小深度 Leetcode47.全排列 II Leetcode216.组合总和 III Leetcode51.N 皇后 Leetcode463.岛屿的周长 Leetcode529.扫雷游戏 Leetcode672.灯泡开关 Ⅱ
深度搜索处理问题的关键 --- 做leetcode深度搜索类题目小结
Jared的博客
08-24 2323
1.深度优先搜索中的关键 2.深度优先搜索小结 3.深度优先搜索和回溯法的区别 4.深度优先搜索与递归的区别 1.深度优先搜索中的关键 深度搜索算法通常用来 解决 全排列，不重复组合，分组问题，多条路径，路径的条数等等 对于深度优先搜索，最重要的参数有两个，第一是 深度搜索的次数 step，可以看做需要将待搜索的结果放入到 step 个盒子中，直到放满为止。 第二个是每一...
2022天梯赛补题
qq_52760486的博客
04-26 1944
2022天梯赛（补题）
L3-032 关于深度优先搜索和逆序对的题应该不会很难吧这件事
qq_39602052的博客
04-27 563
传送门 idea： 参考自“我是小蜗蜗” namo，除了remake，能不能像两位老师一样强啊 考虑单独的一个dfs序，存在父子关系的点对是否逆序数已确定，不存在父子关系的点对是否逆序数的概率各占12\frac{1}{2}21​ 统计dfs序个数，考虑维护一个子树的dfs序数，当前节点的dfs序数等于(∏\prod∏以其子节点为根的子树的dfs序数)×\times×(子节点的排列数) code： f[] 为以u为子树的dfs序方案数，cntRev为在一个dfs序中确定的逆序对数量，cntNum为在一个dfs
dna匹配leetcode-leetcode:leetcode刷题
06-30
深度优先遍历 回溯 先检查后修改 Group Anagrams 排序 unordered_map Minimum Window Substring 两个指针遍历 map Maximal Rectangle 栈 局部递增 或者 动态规划 Binary Tree Inorder Traversal 栈 递归 Single ...
leetcode刷题，C++刷题技巧
11-08
书中将内容分为算法和数据结构两大部分，涵盖了十五个章节，包括但不限于数组、动态规划、数学、字符串、树、哈希表、深度优先搜索、二分查找、贪心算法、广度优先搜索和双指针等常见题型。 贪心算法章节介绍了如何...
leetcode下载-leetcode-record:leetcode刷题记录
06-29
leetcode下载 cpp stack.top() 对于int不会返回-1, 需要提前判断. 剑指offer 9 1.添加元素直接添加； 2.删除元素时判断第二个栈是不是空，是的话一次性将第一个栈...深度优先+迭代 以及 宽度优先+迭代 jz30 解法2 和
树Tree深度优先搜索DFS解题套路【LeetCode刷题套路教程9】
08-30
树Tree深度优先搜索DFS解题套路【LeetCode刷题套路教程9】
非科班出身程序员刷题-leetcode:按tag区分的刷题列表,充会员整理的按leetcode频率热度排序的刷题列表每个tag的top42(宇
07-07
深度优先搜索 二分查找 贪心 双指针 广度优先搜索 栈 回溯算法 设计 链表 排序 堆 位运算 图 并查集 分治算法 滑动窗口 】 字典树 递归 有序映射 线段树 队列 数学 极小化极大 树状数组 Random 拓扑排序 脑筋急转弯 ...
力扣刷题——DFS深度优先搜索算法
how的博客
09-14 1084
岛屿数量 给你一个由 '1'（陆地）和 '0'（水）组成的的二维网格， 请你计算网格中岛屿的数量。 岛屿总是被水包围， 并且每座岛屿只能由水平方向或竖直方向上相邻的陆地连接形成。 此外，你可以假设该网格的四条边均被水包围。 示例 1: 输入: [ [‘1’,‘1’,‘1’,‘1’,‘0’], [‘1’,‘1’,‘0’,‘1’,‘0’], [‘1’,‘1’,‘0’,‘0’,‘0’], [‘0’,‘0’,‘0’,‘0’,‘0’] ] 输出: 1 示例 2: 输入: [ [‘1’,‘1’,‘0’,..
力扣树专题-5 深度优先搜索 leetcode104 101 112 543 129 五道题小练一下深度优先遍历搜索算法 java刷题笔记
一碗菜粥的博客
06-08 245
DFS深度优先搜索算法专题 持续更新中！碰到好题就扔进来！
深度优先搜索（DFS）之习题分析
hyyyya的博客
01-07 728
深度优先搜索（DFS）之习题分析一、深度优先搜索（DFS）的概念二、全排列（一）、题目需求（二）、解法（三）、代码分析三、子集（一）、题目需求（二）、解法（三）、代码分析四、n皇后（一）、题目需求（二）、解法（三）、代码分析 一、深度优先搜索（DFS）的概念 ​ 深度优先搜索（缩写DFS）有点类似广度优先搜索，也是对一个连通图进行遍历的算法。它的思想是从一个顶点V0开始，沿着一条路一直走到底，如果发现不能到达目标解，那就返回到上一个节点，然后从另一条路开始走到底，这种尽量往深处走的概念即是深度优先的概念。
深度优先搜索练习之神奇的矩环（dfs 找环）
Are_you_ready的博客
08-19 282
深度优先搜索练习之神奇的矩环 Time Limit: 1000 ms Memory Limit: 65536 KiB Problem Description 小鑫的女朋友被魔王抢走了！ 魔王留给小鑫一张n*m大的表，上面有各种各样的颜色，用A-Z这26个字母来表示。魔王留给他一个任务，如果小鑫可以在这张表中找出任意一个长度大于1的环，并且这个环的颜色是相同的，魔王就把小鑫的女朋友还给他。为了从魔王手中夺回他的女朋友，小鑫请你帮忙，你能帮帮他吗？ Input 多组输入。 每组的第一行有两个整数n,m。代表表的
LeetCode广搜深搜专题
长期更新Java自学笔记
04-14 301
题目描述 这题是可以被一步捕获的棋子数的升级版，“可以被一步捕获的棋子数”只是从一个点开始遍历，而本题把所有的点都作为起始点遍历 int visit(vector<vector<int>>& grid, int init_x, int init_y){ //这里判断时要注意，一定先判断是否越界，再判断值是否为0，否则报错看不出来，我就找了好长时间。。。 ...
刷题 深度优先搜索（dfs）
qq_31467305的博客
09-04 175
1
深度优先搜索（DFS）总结
Weleness的博客
02-02 5274
深度优先搜索（DFS）图的搜索算法深度优先搜索图示题例总结 图的搜索算法 深度优先搜索（又称DFS）是图的搜索算法的其中一种，另一种是广度优先搜索（BFS） 图的搜索算法可以看成是，从图的某一个点开始，通过遍历顶点和标记顶点来搜索图。 深度优先搜索 以迷宫问题为例，一个人被困在了迷宫里，为了走出迷宫，这个人需要访问迷宫的每一条路径和每一个十字路口（假设在最坏的情况下），那么怎么使得这个人记住他走...
LeetCode —— 深搜水题记录
weixin_34204057的博客
07-28 101
正文之前 好长一段时间没有更新博客了，是因为放假了都是一整个白天地去学车，然后晚上看看书，做一做题就过去了，好在已经完成驾照考试，但是最近又没有研究什么技术，所以就只好拿这几天做的 LeetCode 的记录来假装是一篇博客吧 正文 去年就注册了 LeetCode，但一直没去做，现在放假刚好找点题，就先下手 LeetCode 上的深搜了，因为相当于重新学一遍算法，所以都先做的 Easy 的题 在 G...
LeetCode刷题 - 广度优先搜索与深度优先搜索小结
happylls666的博客
06-17 384
刷题广度优先搜索与深度优先搜索小结
LeetCode 刷题汇总1
08-03
LeetCode 刷题汇总1;LeetCode 刷题汇总1; LeetCode 刷题汇总1;LeetCode 刷题汇总1;LeetCode是一家专注于编程技能提升的在线学习平台，提供了大量的算法题目供用户练习。通过刷LeetCode题目，可以帮助提升编程能力和...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

nuist__NJUPT

给个鼓励吧，谢谢你

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

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

打赏作者

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

抵扣说明：

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

余额充值