leetcode之DFS+BFS+DSU刷题总结1

最新推荐文章于 2022-08-04 14:17:00 发布
最新推荐文章于 2022-08-04 14:17:00 发布
阅读量514 收藏
点赞数 2
分类专栏： 算法与数据结构 文章标签： 深度优先 leetcode dfs bfs dsu
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/nuist_NJUPT/article/details/122946730
版权

leetcode之dfs+bfs+dsu刷题总结1

1-所有可能的路径
题目链接：题目链接戳这里！！！

思路：dfs搜索所有路径，并用栈记录搜索轨迹。

class Solution {
    Stack<Integer> stack = new Stack<>() ;
    List<List<Integer>> list = new ArrayList<>() ;
    public List<List<Integer>> allPathsSourceTarget(int[][] graph) {
        dfs(0,graph) ;
        return list ;
    }
    public void dfs(int x, int [][] graph){
        stack.push(x) ;
        if(x==graph.length-1){
            list.add(new ArrayList<>(stack)) ;
        }
        for(int y : graph[x]){
            dfs(y,graph) ;
        }
        stack.pop() ;
    }
}

在这里插入图片描述
2-判断二分图
题目链接：题目链接戳这里！！！

思路：dfs+染色法。

我们使用图搜索算法从各个连通域的任一顶点开始遍历整个连通域，遍历的过程中用两种不同的颜色对顶点进行染色，相邻顶点染成相反的颜色。这个过程中倘若发现相邻的顶点被染成了相同的颜色，说明它不是二分图；反之，如果所有的连通域都染色成功，说明它是二分图。

class Solution {
    public boolean isBipartite(int[][] graph) {
        int [] vis = new int [graph.length] ;
        for(int i=0; i<graph.length; i++){
            if(vis[i]==0 && !dfs(graph,i,1,vis)){
                return false ;
            }
        }
        return true ;
    }
    public boolean dfs(int [][] graph, int x, int color, int [] vis){
        if(vis[x]!=0){
            return vis[x] == color ;
        }
        vis[x] = color ;
        for(int y : graph[x]){
            if(!dfs(graph,y,-color,vis)){
                return false ;
            }
        }
        return true ;

    }
}

在这里插入图片描述
思路2：bfs+染色法
对于每个顶点，如果未被访问过，则入队，对于该顶点的所有邻接顶点，如果已经被染色，且颜色与当前颜色相同，则不是二分图，如果未被染色，则应染成和相邻顶点相同的颜色。

class Solution {
    public boolean isBipartite(int[][] graph) {
        int [] vis = new int [graph.length] ;
        Queue<Integer> queue = new LinkedList<>() ;
        for(int i=0; i<graph.length; i++){
            if(vis[i]!=0){
                continue ;
            }
            queue.add(i) ;
            vis[i] = 1 ;
            while(!queue.isEmpty()){
                int x = queue.poll() ;
                for(int y : graph[x]){
                    if(vis[y]==vis[x]){
                        return false ;
                    }
                    if(vis[y]==0){
                        vis[y] = -vis[x] ;
                        queue.add(y) ;
                    }
                }
            }
        }
        return true ; 
    }
}

在这里插入图片描述
3-地图中的最高点
题目链接：题目链接戳这里！！！

思路：多源bfs
题目要求让矩阵中的最高高度最大，我们可以通过最大化每个格子的高度来做到这一点。由于任意相邻的格子高度差至多为 1，这意味着对于每个格子，其高度至多比其相邻格子中的最小高度多 1。

题目要求水域的高度必须为 0，因此水域的高度是已经确定的值，我们可以从水域出发，推导出其余格子的高度：

首先，计算与水域相邻的格子的高度。对于这些格子来说，其相邻格子中的最小高度即为水域的高度 0，因此这些格子的高度为 1。
然后，计算与高度为 1 的格子相邻的、尚未被计算过的格子的高度。对于这些格子来说，其相邻格子中的最小高度为 1，因此这些格子的高度为 2。
以此类推，计算出所有格子的高度。

记录下所有水域的位置，然后执行广度优先搜索，计算出所有陆地格子的高度，即为答案。

class Solution {
    int [] dx = {-1,1,0,0} ;
    int [] dy = {0,0,-1,1} ;
    public int[][] highestPeak(int[][] isWater) {
        int [][] ans = new int [isWater.length][isWater[0].length] ;
        for(int i=0; i<ans.length; i++){
            Arrays.fill(ans[i], -1) ; //初始化所有顶点未被访问
        }
        Queue<int[]> queue = new ArrayDeque<int[]>() ;
        for(int i=0; i<isWater.length; i++){
            for(int j=0; j<isWater[0].length; j++){
                if(isWater[i][j]==1){
                    ans[i][j] = 0 ;
                    queue.add(new int []{i,j}) ;
                }
            }
        }
        while(!queue.isEmpty()){
            int [] p = queue.poll() ;
            for(int i=0; i<4; i++){
                int tx = p[0] + dx[i] ;
                int ty = p[1] + dy[i] ;
                if(tx>=0 && ty>=0 && tx<isWater.length && ty<isWater[0].length && ans[tx][ty]==-1){
                    ans[tx][ty] = ans[p[0]][p[1]] + 1 ;
                    queue.add(new int []{tx,ty}) ;

                }
            }
        }
        return ans ;
    }
}

在这里插入图片描述
4-所有路径
题目链接：题目链接戳这里！！！

思路：dfs+栈记录
从0号顶点出发，依次搜索相邻顶点，并用栈记录搜索轨迹。

class Solution {
    List<List<Integer>> list = new ArrayList<>() ;
    Stack<Integer> stack = new Stack<>() ;
    public List<List<Integer>> allPathsSourceTarget(int[][] graph) {
        dfs(graph,0) ;
        return list ;
    }
    public void dfs(int [][] graph, int x){
        stack.push(x) ;
        if(x==graph.length-1){
            list.add(new ArrayList<>(stack)) ;
        }
        for(int y : graph[x]){
            dfs(graph,y) ;
        }
        stack.pop() ;
    }
}

在这里插入图片描述
5-多余的边
题目链接：题目链接戳这里！！！

思路:并查集
在一棵树中，边的数量比节点的数量少 1。如果一棵树有 n 个节点，则这棵树有 n−1 条边。这道题中的图在树的基础上多了一条边，因此边的数量也是 n。

树是一个连通且无环的无向图，在树中多了一条边之后就会出现环，因此多余的边即为导致环出现的边。

可以通过并查集寻找多余的边。初始时，每个节点都属于不同的连通分量。遍历每一条边，判断这条边连接的两个顶点是否属于相同的连通分量。

如果两个顶点属于不同的连通分量，则说明在遍历到当前的边之前，这两个顶点之间不连通，因此当前的边不会导致环出现，合并这两个顶点的连通分量。

如果两个顶点属于相同的连通分量，则说明在遍历到当前的边之前，这两个顶点之间已经连通，因此当前的边导致环出现，为多余的边，将当前的边作为答案返回。

class Solution {
    public int[] findRedundantConnection(int[][] edges) {
        int n = edges.length ;
        int [] parent = new int [n+1] ;
        for(int i=1; i<=n; i++){
            parent[i] = i ;
        }
        for(int i=0; i<n; i++){
            int [] edge = edges[i] ;
            int node0 = edge[0], node1 = edge[1] ;
            if(find(parent,node0)!=find(parent,node1)){
                union(parent,node0,node1) ;
            }else{
                return edge ;
            }
        }
        return new int []{} ;
    }
    public int find(int [] parent, int node){
        if(node!=parent[node]){
            parent[node] = find(parent,parent[node]) ;
        }
        return parent[node] ;
    }
    public void union(int [] parent, int node1, int node0){
        parent[parent[node1]] = find(parent,parent[node0]) ;
    }
}

在这里插入图片描述
6-矩阵中的距离
题目链接：题目链接戳这里！！！

思路：bfs
首先将所有的0入队，然后多元广度优先搜索，如果其它相邻点未搜索过，则为当前点加1.

class Solution {
    int [] dx = {-1,1,0,0} ;
    int [] dy = {0,0,-1,1} ;
    public int[][] updateMatrix(int[][] mat) {
        //广度优先搜索
        int m = mat.length ;
        int n = mat[0].length ;
        Queue<int[]> queue = new LinkedList<int[]>() ;
        int [][] ans = new int [m][n] ;
        boolean [][] vis = new boolean [m][n] ;
        for(int i=0; i<m; i++){
            for(int j=0; j<n; j++){
                if(mat[i][j] == 0){
                    queue.add(new int [] {i,j}) ;
                    vis[i][j] = true ;
                }
            }
        }
        while(!queue.isEmpty()){
            int [] edge = queue.poll() ;
            for(int i=0; i<4; i++){
                int tx = edge[0] + dx[i] ;
                int ty = edge[1] + dy[i] ;
                if(tx>=0 && ty>=0 && tx<m && ty<n && !vis[tx][ty]){
                    ans[tx][ty] = ans[edge[0]][edge[1]] + 1 ;
                    queue.add(new int []{tx,ty}) ;
                    vis[tx][ty] = true ;
                }
            }
        }
        return ans ;
    }
}

在这里插入图片描述
7-最小基因变化
题目链接：题目链接戳这里！！！

思路：bfs+剪枝
题目给定一个起始字符串start和一个目标字符串end, 其中start只能通过以下步骤变化为新的字符串。

每一次变化，都只能用"A", “C”, “G”, "T"里的任意一个字母替换当前字符串里的某一个字母。
替换后得到的新的字符串必须在给定的bank里。
明确这两点之后，我们很容易地想到这个题建模为树(具体来说，无权树)，可知只不过这个树的子树会比较多，可以剪枝。

class Solution {
    public int minMutation(String start, String end, String[] bank) {
        Set<String> bankSet = new HashSet<>() ;
        for(String str : bank){
            bankSet.add(str) ;
        }
        String [] gene = {"A","C","G","T"} ;
        Set<String> vis = new HashSet<>() ;
        Queue<String> queue = new LinkedList<>() ;
        vis.add(start) ;
        queue.add(start) ;
        int step = 0 ;
        while(!queue.isEmpty()){
            int size = queue.size() ;
            for(int k=0; k<size; k++){
            String s = queue.poll() ;
            if(s.equals(end)){
                return step ;
            }
            for(int i=0; i<s.length(); i++){
                StringBuilder cur = new StringBuilder(s) ;
                for(int j=0; j<gene.length; j++){
                   String ans =  cur.replace(i,i+1,gene[j]).toString() ;
                    if(!vis.contains(ans) && bankSet.contains(ans)){
                        queue.add(ans) ;
                        vis.add(ans) ;
                    }
                }
            }
         }
            step ++ ;
        }
        return -1 ;
    }
}

在这里插入图片描述
8-打开转盘锁
题目链接：题目链接戳这里！！！

思路：bfs+剪支
我们可以使用广度优先搜索，找出从初始数字 0000 到解锁数字target 的最小旋转次数。

具体地，我们在一开始将 0000 加入队列，并使用该队列进行广度优先搜索。在搜索的过程中，设当前搜索到的数字为 status，旋转的次数为 step，我们可以枚举 status 通过一次旋转得到的数字。设其中的某个数字为 next，如果其没有被搜索过，我们就将 next加入队列。如果搜索到了target，我们就返回其对应的旋转次数。

为了避免搜索到死亡数字，我们可以使用哈希表存储 deadends 中的所有元素，这样在搜索的过程中，我们可以均摊 O(1)地判断一个数字是否为死亡数字。同时，我们还需要一个哈希表存储所有搜索到的状态，避免重复搜索。

如果搜索完成后，我们仍没有搜索到 target，说明我们无法解锁，返回 -1。

class Solution {
    public int openLock(String[] deadends, String target) {
        if("0000".equals(target)){
            return 0 ;
        }
        Set<String> deadSet = new HashSet<>() ;
        for(String str : deadends){
            deadSet.add(str) ;
        }
        Set<String> vis = new HashSet<>() ;
        Queue<String> queue = new LinkedList<>() ;
        vis.add("0000") ;
        queue.add("0000") ;
        if(deadSet.contains("0000")){
            return -1 ;
        }

        int step=0;
        while(!queue.isEmpty()){
            step ++  ;
            int size = queue.size() ;
            for(int i=0; i<size; i++){
                String status = queue.poll() ;
                for(String next : get(status)){
                    if(!vis.contains(next) && !deadSet.contains(next)){
                        if(next.equals(target)){
                            return step ;
                        }
                        queue.add(next) ;
                        vis.add(next) ;
                    }
                }
            }
        }
        return -1 ;
    }
    public char f1(char ch){
        return ch=='9' ? '0' : (char)(ch+1) ;
    }
    public char f2(char ch){
        return ch=='0' ? '9' : (char)(ch-1) ;
    }
    public List<String> get(String s){
        List<String> res = new ArrayList<>() ;
        char [] c = s.toCharArray() ;
        for(int i=0; i<c.length;i++){
            char num = c[i] ;
            c[i] = f1(c[i]) ;
            res.add(new String(c)) ;
            c[i] = f2(num) ;
            res.add(new String(c)) ;
            c[i] = num ;
        }
        return res ;
    }
}

在这里插入图片描述
9-连通网络的操作次数
题目链接：题目链接戳这里！！！

思路1：并查集
我们可以使用并查集来得到图中的连通分量数。
并查集本身就是用来维护连通性的数据结构。如果其包含 n 个节点，那么初始时连通分量数为 n，每成功进行一次合并操作，连通分量数就会减少 1。

将所有已经联通的合并为一个集合，每次访问每个元素的根节点，如果不是它本身，联通分量就累加1，联通分量数减1就是答案。

class Solution {
    public int makeConnected(int n, int[][] connections) {
        if(n-1>connections.length){
            return -1 ;
        }
        //并查集
        int [] parent = new int [n+1] ;
        for(int i=1; i<=n; i++){
            parent[i]  = i ;
        }
        for(int [] connection : connections){
            union(parent,connection[0]+1,connection[1]+1) ;
        }
        int cnt = 0 ;
        for(int i=1; i<=n; i++){
            if(i==parent[i]){
                cnt ++ ;
            }
        }
        return cnt - 1 ;
    }
    public int find(int [] parent, int x){
        if(x!=parent[x]){
            parent[x] = find(parent,parent[x]) ;
        }
        return parent[x] ;
    }
    public void union(int [] parent, int x, int y){
        int root1 = find(parent,x) ;
        int root2 = find(parent,y) ;
        if(root1==root2){
            return ;
        }
        parent[root1] = root2 ;
    }
}

在这里插入图片描述
思路2：dfs
建立双向邻接表，然后深度优先搜索，统计联通分量个数，联通分量个数减去1就是答案。然而深搜的效率比并查集低很多。

class Solution {
    public int makeConnected(int n, int[][] connections) {
        if(n-1>connections.length){
            return -1 ;
        }
        List<List<Integer>> edges = new ArrayList<>() ;
        for(int i=0; i<n; i++){
            edges.add(new ArrayList<>()) ;
        }
        for(int [] connection : connections){
            edges.get(connection[0]).add(connection[1]) ;
            edges.get(connection[1]).add(connection[0]) ;
        }
        int ans = 0 ;
        boolean [] vis = new boolean[n] ;
        for(int i=0; i<n; i++){
            if(!vis[i]){
            dfs(edges,i,vis) ;
            ans ++ ;
            }
        }
        return ans - 1 ;
    }
    public void dfs(List<List<Integer>> edges, int x, boolean [] vis){
        vis[x] = true ;
        for(int y : edges.get(x)){
            if(!vis[y]){
                dfs(edges,y,vis) ;
            }
        }
    }
}

在这里插入图片描述
10-开锁密码
题目链接：题目链接戳这里！！！

思路：bfs+剪支
我们可以使用广度优先搜索，找出从初始数字 0000 到解锁数字target 的最小旋转次数。

具体地，我们在一开始将 0000 加入队列，并使用该队列进行广度优先搜索。在搜索的过程中，设当前搜索到的数字为 str，旋转的次数为 step，我们可以枚举 str 通过一次旋转得到的数字。设其中的某个数字为 next，如果其没有被搜索过，我们就将 next加入队列。如果搜索到了target，我们就返回其对应的旋转次数。

为了避免搜索到死亡数字，我们可以使用哈希表存储 deadends 中的所有元素，这样在搜索的过程中，我们可以均摊 O(1)地判断一个数字是否为死亡数字。同时，我们还需要一个哈希表存储所有搜索到的状态，避免重复搜索。

如果搜索完成后，我们仍没有搜索到 target，说明我们无法解锁，返回 -1。

class Solution {
    public int openLock(String[] deadends, String target) {
        //广度优先搜索
        if("0000".equals(target)){
            return 0 ;
        }
        Set<String> deadSet = new HashSet<>() ;
        for(int i=0; i<deadends.length; i++){
            deadSet.add(deadends[i]) ;
        }
        Set<String> vis = new HashSet<>() ;
        Queue<String> queue = new LinkedList<>() ;
        vis.add("0000") ;
        queue.add("0000") ;
        if(deadSet.contains("0000")){
            return -1 ;
        }
        int step = 0 ;
        while(!queue.isEmpty()){
            step ++ ;
            int size = queue.size() ;
            for(int i=0; i<size; i++){
                String str = queue.poll() ;
                for(String next : get(str)){
                    if(!vis.contains(next) && !deadSet.contains(next)){
                    if(next.equals(target)){
                        return step ;
                    }
                    queue.add(next) ;
                    vis.add(next) ;
                }
                }
            }
        }
        return -1 ;
    }
    public List<String> get(String s){
        char [] c = s.toCharArray() ;
        List<String> ans = new ArrayList<>() ;
        for(int i=0; i<c.length; i++){
            char num = c[i] ;
            c[i] = f1(c[i]) ;
            ans.add(new String(c)) ;
            c[i] = f2(num) ;
            ans.add(new String(c)) ;
            c[i] = num ;
        }
        return ans ;
    }
    public char f1(char ch){
        return ch=='9' ? '0' : (char)(ch+1) ;
    }
    public char f2(char ch){
        return ch=='0' ? '9' : (char)(ch-1) ;
    }
}

在这里插入图片描述
11-颜色填充
题目链接：题目链接戳这里！！！

思路1：dfs+标记
如果四个方向满足条件，就沿着四个方向搜索，并涂色。

class Solution {
    int [] dx = {-1,1,0,0} ;
    int [] dy = {0,0,-1,1} ;
    public int[][] floodFill(int[][] image, int sr, int sc, int newColor) {
        
        dfs(image,sr,sc,newColor,image[sr][sc]) ;
        return image ;
    }
    public void dfs(int [][] image, int x, int y, int newColor, int n){
        image[x][y] = newColor ;
        for(int i=0; i<4; i++){
            int tx = x + dx[i] ;
            int ty = y + dy[i] ;
            if(tx>=0 && ty>=0 && tx<image.length && ty<image[0].length && image[tx][ty]==n && image[tx][ty]!=newColor){
                dfs(image,tx,ty,newColor,n) ;
            }
        }
    }
}

在这里插入图片描述
思路2：bfs
将第一个坐标位置涂色，并将坐标入队，每次沿着四个方向涂色即可。

class Solution {
    int [] dx = {-1,1,0,0} ;
    int [] dy = {0,0,-1,1} ;
    public int[][] floodFill(int[][] image, int sr, int sc, int newColor) {
        Queue<int[]> queue = new LinkedList<int[]>() ;
        int n = image[sr][sc] ;
        image[sr][sc] = newColor ;
        queue.add(new int []{sr,sc}) ;
        while(!queue.isEmpty()){
            int [] a = queue.poll() ;
            for(int i=0; i<4; i++){
                int tx = a[0] + dx[i] ;
                int ty = a[1] + dy[i] ;
                if(tx>=0 && ty>=0 && tx<image.length && ty<image[0].length && image[tx][ty] != newColor && image[tx][ty]==n){
                    image[tx][ty] = newColor ;
                    queue.add(new int []{tx,ty}) ;
                }
            }
        }
        return image ;

    }
}

在这里插入图片描述

日拱一卒无有即尽，功不唐娟终入海，稳住，少年！

nuist__NJUPT
关注
  • 2
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Leetcode DFS系列算法回顾和总结
Ricardo Wang
09-02 605
刷LeetCode一定要总结，不然就是走马观花，很难体会到其中的精髓 DFS系列的算法相比其他算法，本人是觉得是相对比较抽象的。其他的算法，比如动态规划，排序等，只要处理好每一步的处理结构就能很好的完成算法的设计和实现。但是DFS算法需要比较高的抽象能力，不光要处理每一步的流程，还要兼顾每一次迭代对其他迭代的影响，因为在设置迭代单元的时候，需要很好的界定功能边界。 LeeTcode...
leetcode-dfs总结
LLM1602的博客
03-18 875
一：二分图：颜色分图 1:leetcode:785https://leetcode-cn.com/problems/is-graph-bipartite/ 思想：即然要分成两组，二分，即颜色不同，把一天边的两个结点分成A,B两个集合，则考虑用一个颜色（eg:蓝色）赋予当 前结点，把与它相邻的结点赋予另一颜色（...
LeetCode - DFS (depth-first-search) 总结
real_lisa的博客
10-11 188
每行选一题先感受一下～   基础 Subset I, II (contain duplicates) Combinations Permutation I, II (contain duplicates) Combinations Sum I, II (can only be used once), III 一维 Generate Parentheses Letter Combi...
leetcode-深度优先搜索总结（DFS）
Less is More
04-06 204
TODO------------
leetcode算法总结 —— DFS深度优先搜索
Charles Ren's Tech Blog
02-03 572
文章目录DFS自顶向下（根节点到叶子节点）（前序处理）（向下传参）同时遍历两个树自底向上（子节点到子节点） (后序处理)构建二叉树通过前/后 和中序遍历构造二叉树 DFS 模板 dfs(TreeNode* root, int path) { //父节点要传给子节点值，则放到递归的形参中。`void dfs(TreeNode* root, int path)` if(root == nullptr) return; //return放递归上面则会终止到当前节点，不继续向下面子树遍历，不执行
LeetCode：LeetCode C ++ Python解决方案
02-02
LeetCode LeetCode C ++ / Python解决方案
列表实现岛屿数量（DFS+BFS）
12-21
列表实现岛屿数量（DFS+BFS） ** 给定一个由 ‘1’（陆地）和 ‘0’（水）组成的的二维网格，计算岛屿的数量。一个岛被水包围，并且它是通过水平方向或垂直方向上相邻的陆地连接而成的。你可以假设网格的四个边均被...
leetcode中DFS与BFS算法在数组和字符串中的应用
12-20
DFS（深度优先遍历）与BFS（广度优先遍历）算法是基于树和图结构进行遍历的两种算法。 一般来说DFS在前中后遍历中运用比较明显，DFS的运用基本是要利用递归进行嵌套使用。回溯算法其实也是一种比较经典的DFS算法升级...
数据结构和算法基础的实现+笔记+LeetCode 刷题记录 + 一些书籍整理。.zip
最新发布
01-14
数据结构和算法基础的实现+笔记+LeetCode 刷题记录 + 一些书籍整理。
leetcode分类-LeetCode:LeetCodeC++题解
06-30
leetcode 分类 LeetCode C++题解 按照题目难度分的文件夹 demo.cpp : 创建每个文件的模板 test.cpp : 写一些提交代码测试用例的文件 .vscode : 是vscode环境下C++的配置文件 include"bits/stdc++.h"尽量不要使用 会...
leetcode-回溯问题总结（DFS）
littlewhitevg的博客
05-12 788
1.DFS 图论里邻接表的DFS private void dfs(boolean[] isVisited, int i) { //将结点设置为已经访问 isVisited[i] = true; //查找结点i的第一个邻接结点w int w = getFirstNeighbor(i); while(w != -1) {//说明存在当前临界点 if(!isVisited[w]) {
leetcode -遇到DFS汇总篇
xz_4321的博客
08-04 279
DFS算法
leetcode 46 不重复数组全排列 47. 全排列 II
chen_ethan的博客
02-10 226
题目： 给定一个没有重复数字的序列，返回其所有可能的全排列。 易错点： 正确写法： (*returnColumnSizes)[i] = numsSize; 错误写法：*returnColumnSizes[i] = numsSize; /** * Return an array of arrays of size *returnSize. * The sizes of the ...
LeetCode刷题总结--DFS与字符串处理
To_be_thinking的博客
05-09 462
388. Longest Absolute File Path "dir\n\tsubdir1\n\t\tfile1.ext\n\t\tsubsubdir1\n\tsubdir2\n\t\tsubsubdir2\n\t\t\tfile2.ext"则个字符串序列是由文件目录树的深度优先搜索（先根遍历）得到的，所以需要借助栈来进行解析这个字符串得到所有全路径，从而比较全路径字符串的长度。这里要注意的是...
leetcode思路总结反思(dfs篇)
weixin_43886143的博客
07-07 166
leetcode思路总结反思(dfs篇) 130. Surrounded Regions （dfs蚕食法专题) 使用dfs,利用“蚕食法”，核心代码模板如下： for(int i=0;i<row;i++) { check(board,i,0,row,col); check(board,i,col-1,row,col); } ...
leetcode DFS汇总贴 更新ing
clearlove_7的博客
05-01 282
leetcode DFS汇总贴 更新ing题目描述知识点：DFS（深搜问题）200. 岛屿数量（5-1更新）695. 岛屿的最大面积（5-1更新） 在家这么久刷了不少题，也想着总结一下，欢迎看到的小伙伴一起打卡，监督学习进步，欢迎加v:15810853703,趁着五一节来更新一下博客qaq 题目描述 知识点：DFS（深搜问题） 200. 岛屿数量（5-1更新） https://leetcode...
LeetCode刷题记录---并查集（DSU）算法
weixin_43646592的博客
07-24 493
每次刷到并查集（DSU）算法题将在此博文更新~~~ 关于并查集的资料请看以下2个链接： 1.什么是并查集？ 2.【图解】遇到就深究——并查集 并查集是一种树型的数据结构，用于处理一些不相交集合（disjoint sets）的合并及查询问题。     以下为DSU的python简单实现（关于DSU的find部分和union部分的优化可以看上面：链接2） class DSU: def __init__(self, nums): self.parent = {num: num for nu
leetcode-45. 跳跃游戏 II--【BFS+剪枝】-【贪心】
超级氯化钾的博客
05-11 100
文章目录BFS + 剪枝 勉强ACJAVA超时 BFS + 剪枝 勉强AC class Solution { public: //BFS+剪枝 int jump(vector<int>& nums) { int len = nums.size(); queue<pair<int,int>> q; // pair<index,step> q.push(make_pair(0,0));
LeetCode刷题 - 高级算法扩展小结
happylls666的博客
07-09 1400
LeetCode刷题高级算法拓展小结
leetcode+2866
11-09
根据提供的引用内容，第一个问题似乎不是一个问题，因为它只是提供了一个LC的下载链接和一个Zoom会议的信息。而第二个引用则提供了一个解决LC 268题的C++代码。因此，我将为您提供有关LC 268题和LC网站的一些信息。\n\LC是一个在线的技术面试平台，提供了各种算法和数据结构问题的练习和挑战。LC 268题要求您找到到中缺失的数字，其中是数组的长度，数组中的数字是到之间的连续数字，但是有一个数字缺失了。您可以使用求和公式来找到缺失的数字，然后减去数组中所有数字的总和。您也可以使用位运算或排序等其他方法来解决这个问题。\n\下面是一个使用位运算的Pyth代码示例：\n\```pyth\ss Soluti\ def missingNumber(self, nums Lis[i]) -> i\ missing = (nums)\ for i, num i enumer(nums):\ missing ^= i ^ num\ retur missing\```\n\

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

nuist__NJUPT

给个鼓励吧，谢谢你

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

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

打赏作者

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

抵扣说明：

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

余额充值