BFS

最新推荐文章于 2023-09-28 12:18:32 发布
最新推荐文章于 2023-09-28 12:18:32 发布
阅读量155 收藏
点赞数
分类专栏： 算法 文章标签： 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/LaMole_Ryouji/article/details/108936095
版权

二叉树的最小深度

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */

class Solution {
    public int minDepth(TreeNode root) {
        int result = 0;
        if (root == null) {
            return result;
        }
        
        Queue<TreeNode> queue = new LinkedList<>();
        queue.offer(root);
        result++;
        while (!queue.isEmpty()) {
            int m = queue.size();
            for (int i = 0; i < m; i++) {
                TreeNode current = queue.poll();
                if (current.left != null) {
                    queue.offer(current.left);
                }
                if (current.right != null) {
                    queue.offer(current.right);
                }

                if (current.left == null && current.right == null) {
                    return result;
                }
            }
            result++;
        }
        return result;
    }
}

打开转盘锁

class Solution {
    public int openLock(String[] deadends, String target) {
        return bfs("0000", deadends, target);
    }
    public int bfs(String current, String[] deadends, String target) {
        Queue<String> queue = new LinkedList<>();
        queue.offer(current);
        int result = 0;
        Set<String> seen = new HashSet<>();
        while (!queue.isEmpty()) {
            int m = queue.size();
            for (int i = 0; i < m; i++) {
                String now = queue.poll();
                if (now.equals(target)) {
                    return result;
                }
                if (seen.contains(now)) {
                    continue;
                }
                seen.add(now); 
                if (contains(now, deadends)) {
                    continue;
                }
                queue.offer(change(1, 0, 0, 0, now));
                queue.offer(change(-1, 0, 0, 0, now));
                queue.offer(change(0, 1, 0, 0, now));
                queue.offer(change(0, -1, 0, 0, now));
                queue.offer(change(0, 0, 1, 0, now));
                queue.offer(change(0, 0, -1, 0, now));
                queue.offer(change(0, 0, 0, 1, now));
                queue.offer(change(0, 0, 0, -1, now));
            }
            result++;
        }
        return -1;
    }

    public boolean contains(String current, String[] deadends) {
        for (int i = 0; i < deadends.length; i++) {
            if (deadends[i].equals(current)) {
                return true;
            }
        }
        return false;
    }

    public String change(int one, int two, int three, int four, String current) {
        char o = (char) (current.charAt(0) + one);
        char tw = (char) (current.charAt(1) + two);
        char th = (char) (current.charAt(2) + three);
        char f = (char) (current.charAt(3) + four);
        if (o > '9') {
            o = '0';
        }
        if (tw > '9') {
            tw = '0';
        }
        if (th > '9') {
            th = '0';
        }
        if (f > '9') {
            f = '0';
        }

        if (o < '0') {
            o = '9';
        }
        if (tw < '0') {
            tw = '9';
        }
        if (th < '0') {
            th = '9';
        }
        if (f < '0') {
            f = '9';
        }
        StringBuilder sb = new StringBuilder();
        return sb.append(o).append(tw).append(th).append(f).toString();
    }
}

判断二分图

class Solution {
    private static final int UNDEFINE = 0;
    private static final int RED = 1;
    private static final int GREEN = 2;

    public boolean isBipartite(int[][] graph) {
        int[] colores = new int[graph.length];
        int n = graph.length;
        Arrays.fill(colores, UNDEFINE);
        for (int i = 0; i < n; i++) {
            if (colores[i] != UNDEFINE) {
                continue;
            }
            Queue<Integer> queue = new LinkedList<>();
            queue.add(i);
            colores[i] = RED;
            while (!queue.isEmpty()) {
                int m = queue.poll();
                int color = colores[m] == RED ? GREEN : RED;
                for (Integer integer : graph[m]) {
                    if (colores[integer] == UNDEFINE) {
                        queue.offer(integer);
                        colores[integer] = color;
                    } else if (colores[integer] != color) {
                        return false;
                    }
                }
            }
        }
        
        return true;
    }
}

01 矩阵

class Solution {
    int[][] move = new int[][] {{1, 0}, {0, 1}, {-1, 0}, {0, -1}};
    public int[][] updateMatrix(int[][] matrix) {
        int[][] result = new int[matrix.length][matrix[0].length];
        for (int i = 0; i < matrix.length; i++) {
            for (int j = 0; j < matrix[0].length; j++) {
                if (matrix[i][j] == 0) {
                    result[i][j] = 0;
                } else {
                    int depth = 1;
                    Queue<int[]> queue = new LinkedList<>();
                    queue.offer(new int[] {i, j});
                    boolean flag = true;
                    while (!queue.isEmpty() && flag) {
                        int m = queue.size();
                        for (int k = 0; k < m && flag; k++) {
                            int[] xy = queue.poll();
                            int x = xy[0];
                            int y = xy[1];
                            for (int l = 0; l < move.length; l++) {
                                int xn = x + move[l][0];
                                int yn = y + move[l][1];
                                if (xn < 0 || xn > matrix.length - 1 || yn < 0 || yn > matrix[0].length - 1) {
                                    continue;
                                }
                                if (matrix[xn][yn] == 0) {
                                    result[i][j] = depth;
                                    flag = false;
                                    break;
                                } else {
                                    queue.offer(new int[]{xn, yn});
                                }
                            }
                        }
                        depth++;
                    }
                }
            }
        }
        return result;
    }
}

腐烂的橘子

class Solution {
    private static int[][] move = new int[][] {{1,0},{0,1},{-1,0},{0,-1}};
    public int orangesRotting(int[][] grid) {
        int m = grid.length;
        int n = grid[0].length;
        boolean[][] visited = new boolean[m][n];

        Queue<int[]> queue = new LinkedList<>();
        for (int i = 0; i < m; i++) {
            for (int j = 0; j < n; j++) {
                if (grid[i][j] == 2) {
                    queue.offer(new int[] {i, j});
                }
            }
        }
        int ans = 0;
        while (!queue.isEmpty()) {
            
            boolean flag = true;
            int qm = queue.size();
            for (int j = 0; j < qm; j++) {
                int[] xy = queue.poll();
                int x = xy[0];
                int y = xy[1];
                visited[x][y] = true;
                for (int i = 0; i < move.length; i++) {
                    int xn = x + move[i][0];
                    int yn = y + move[i][1];
                    if (xn < 0 || yn < 0 || xn > m - 1 || yn > n - 1) {
                        continue;
                    }
                    if (visited[xn][yn]) {
                        continue;
                    }
                    if (grid[xn][yn] == 0) {
                        continue;
                    }
                    if (grid[xn][yn] == 1) {
                        grid[xn][yn] = 2;
                        queue.offer(new int[] {xn, yn});
                        if (flag) {
                            ans++;
                            flag = false;
                        }
                    }
                }
            }
        }
        for (int i = 0; i < m; i++) {
            for (int j = 0; j < n; j++) {
                if (grid[i][j] == 1) {       
                    return -1;
                }
            }
        }
        return ans;
    }
}

二叉树的层次遍历 II

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    public List<List<Integer>> levelOrderBottom(TreeNode root) {
        if (root == null) {
            return new ArrayList<>();
        }
        LinkedList<List<Integer>> result = new LinkedList<>();
        Queue<TreeNode> queue = new LinkedList<>();
        queue.offer(root);
        while (!queue.isEmpty()) {
            int m = queue.size();
            List<Integer> list = new ArrayList<>();
            for (int i = 0; i < m; i++) {
                TreeNode current = queue.poll();
                list.add(current.val);
                if (current.left != null) {
                    queue.offer(current.left);
                }
                if (current.right != null) {
                    queue.offer(current.right);
                }
            }
            result.addFirst(list);
        }
        return result;
    }
}

二叉树的锯齿形层次遍历

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    public List<List<Integer>> zigzagLevelOrder(TreeNode root) {
        if (root == null) {
            return new ArrayList<>();
        }
        LinkedList<List<Integer>> result = new LinkedList<>();
        Queue<TreeNode> queue = new LinkedList<>();

        queue.offer(root);
        boolean asc = true;
        while (!queue.isEmpty()) {
            int m = queue.size();
            LinkedList<Integer> temp = new LinkedList<>();
            for (int i = 0; i < m; i++) {
                TreeNode current = queue.poll();
                if (asc) {
                    temp.addLast(current.val);
                } else {
                    temp.addFirst(current.val);
                }
                if (current.left != null) {
                    queue.offer(current.left);
                }
                if (current.right != null) {
                    queue.offer(current.right);
                }
            }
            asc = !asc;
            result.add(temp);
        }
        return result;
    }
}

课程表

class Solution {
    public boolean canFinish(int numCourses, int[][] prerequisites) {
        int[] visited = new int[numCourses];
        List<List<Integer>> ad = new ArrayList<>();

        for (int i = 0; i < visited.length; i++) {
            ad.add(new ArrayList<>());
        }
        for (int i = 0; i < prerequisites.length; i++) {
            visited[prerequisites[i][0]]++;
            List<Integer> list = ad.get(prerequisites[i][1]);
            list.add(prerequisites[i][0]);
        }

        Queue<Integer> queue = new LinkedList<>();
        for (int i = 0; i < numCourses; i++) {
            if (visited[i]==0) {
                queue.offer(i);
            }
        }

        while (!queue.isEmpty()) {
            int c = queue.poll();
            numCourses--;
            for (Integer integer : ad.get(c)) {
                visited[integer]--;
                if (visited[integer] == 0) {
                    queue.offer(integer);
                }
            }
            
        }
        return numCourses == 0;
    }
}

课程表 II

class Solution {
    public int[] findOrder(int numCourses, int[][] prerequisites) {
        int[] visited = new int[numCourses];
        List<List<Integer>> ad = new ArrayList<>();
        for (int i = 0; i < numCourses; i++) {
            ad.add(new ArrayList<>());
        }
        for (int i = 0; i < prerequisites.length; i++) {
            visited[prerequisites[i][0]]++;
            List<Integer> list = ad.get(prerequisites[i][1]);
            list.add(prerequisites[i][0]);
        }

        Queue<Integer> queue = new LinkedList<>();

        for (int i = 0; i < visited.length; i++) {
            if (visited[i] == 0) {
                queue.offer(i);
            }
        }
        int[] result = new int[numCourses];
        int n = numCourses;
        while(!queue.isEmpty()) {
            Integer c = queue.poll();
            result[n - numCourses] = c;
            numCourses--;
            for (Integer integer : ad.get(c)) {
                visited[integer]--;
                if (visited[integer] == 0) {
                    queue.offer(integer);
                }
            }
        }

        return numCourses == 0 ? result : new int[0];
    }
}

完全平方数

class Solution {
    // public int numSquares(int n) {
    //      int[] dp = new int[n+1];
    //      Arrays.fill(dp, n);
    //      dp[1] = 1;
    //      dp[0] = 0;
    //      for (int i = 2; i < n + 1; i++) {
    //          for (int j = 0; j*j <= i; ++j) {
    //             dp[i] = Math.min(dp[i - j*j], dp[i]);
    //          }
    //          dp[i] = dp[i] + 1;
    //      }
    //      return dp[n];
    // }
    public int numSquares(int n) {

        int[] visited = new int[n+1];
        Arrays.fill(visited, -1);
        return fun(n, visited);
    }

    public int fun(int n, int[] visited) {
        if (visited[n] != -1) {
            return visited[n];
        }
        if (n==0) {
            return 0;
        }
        int result = n;
        for (int i = 1; i*i <= n; i++) {
            result = Math.min(result,  fun(n-i*i, visited));
        }
        visited[n] = result + 1;
        return result + 1;
    }
}
LaMole_Ryouji
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
哈工大BFS算法代码
04-07
BFS算法的课程作业，宽度优先搜索算法（又称广度优先搜索）是最简便的图的搜索算法之一，这一算法也是很多重要的图的算法的原型。Dijkstra单源最短路径算法和Prim最小生成树算法都采用了和宽度优先搜索类似的思想
Bfs-Dfs.rar_bfs
09-21
在C环境中使用Bfs，Dfs的遍历算法创建邻接表建立图。
bfs
TGYYS的博客
02-02 3246
bfs原理 bfs就是广度优先搜索，与深度优先搜索有类似之处也有不同之处。 深度优先搜索是不撞南墙不回头的莽夫。 广度优先搜索则像高塔一样稳健。 bfs要先建立一个队列 struct node { int ;//至少两个，一个表示数据，一个表示数据所在的位置。 }; dfs考虑的是当先该怎么做并用递归写出下一次，而bfs考虑的是下一次有几种做法。 我这里给出dfs的文章做对比dfs原理 我...
第十三章 DFS与BFS（保姆级教学！！超级详细的图示！！）
热门推荐
Turing_Sheep的博客
12-02 4万+
用画图和超详细地注释帮助大家秒懂DFS和BFS!!!!保姆级教学！！！解决你的痛点！！！
双向BFS
qq_45832461的博客
04-03 562
双向BFS算法思想 理解 双向BFS适用于已经直到了起点和终点的状态下使用，从起点和终点两个方向开始进行搜索，可以极大地提高单向BFS的搜索效率。 可以设置两个队列，一个队列保存从起点开始搜索的状态，另一个队列用来保存从终点开始搜索的状态，当两个队列都非空时才能继续进行循环。循环内不断对元素较少的队列进行BFS操作(以免退化为单向BFS)，每次操作从队列弹出一个元素，与该元素相连的后续未访问元素压入队列中。如果某一个状态出现相交的情况，那么就出现了答案。 当两种颜色相遇的时候，说明两个方向的搜索树遇到一起，
C++BFS算法
闻缺陷则喜何志丹
09-28 1067
本文介绍了BFS的原理和实现及例题。BFS中文名为广度优先或宽度优先。最经典的应用是图论，但不限于图论。 O(m) ,m是边的数量。许多经典应用场景，如2D游戏地图、网格，出边固定不超过4或8(4联通或8联通），这种情况也可以说BFS的时间复杂度是O(n)，n是端点数。 每个端点只会访问一次，显然第一次访问的是最小距离，第二次访问时距离只会变大或不变，没有继续访问的意义。假定s到x2的最短最短距离经过x1，如果s到x1距离变大，x1到x2的距离不变，则s到x2的距离变大。
宽度优先搜索算法（BFS）详解（超级详细讲解，附有大图）
aliyonghang的博客
01-18 3万+
​ 补充说明：由上可以知道，广度优先搜索的特征为从起点开始，由近及远进行广泛的搜索。因此，目标顶点离起点越近，搜索结束得就越快。 三.对比与发现 DFS和BFS的区别 bfs 遍历节点是先进先出，dfs遍历节点是先进后出； bfs是按层次访问的，dfs 是按照一个路径一直访问到底，当前节点没有未访问的邻居节点时，然后回溯到上一个节点，不断的尝试，直到访问到目标节点或所有节点都已访问。 bfs 适用于求源点与目标节点距离最近的情况，例如：求最短路径。dfs 更适合于求解一个任意符合方案中的一个或者遍历所有情
BFS模板
努力中的老周的专栏
03-03 915
前文，https://blog.csdn.net/justidle/article/details/104631780，我们对 BFS 进行了概要性介绍。从这里我们可以知道 BFS 的实现通常都需要队列 queue（FIFO特性）这个数据结构支持。 BFS 基本框架 下面，我们给出 BFS 算法的基本框架： 1、使用合适的数据结构来描述问题。如描述一个迷宫。 2、定义一个队列，来保存下一步...
BFS(JAVA版讲解)
长夜漫漫，无心睡眠
02-07 1万+
可以先refer to这篇C++版文章 广度优先搜索（Breadth First Search , BFS）遍历类似于树的按层次遍历的过程，则是以广度为第一关键词，当碰到岔道口时，总是先依次访问从该岔道口能直接到达的所有结点，然后再按这些结点被访问的顺序去依次访问它们能直接到达的所有结点，以此类推，直到所有结点都被访问为止。 广度优先搜索的整个算法过程很像一个队列，因此，广度优先搜索一般由...
多源BFS
涛涛的个人博客
01-21 1102
多源BFS 一、简介 多源BFS与单源BFS有什么区别呢？ 单源BFS：从某一个点开始（起点） 多源BFS：从多个点同时开始走 如何解决多源BFS？ 多源BFS：多个起点 ——> 多个起点同时加入队列！ 核心：在求解多源BFS问题时，同时将所有起点加入队列即可！ 二、练习 1.矩阵距离 【题目链接】173. 矩阵距离 - AcWing题库 给定一个 NN 行 MM 列的 0101 矩阵 AA，A[i] [j] 与A[k] [l] 之间的曼哈顿距离定义为： dist(A[i] [j],
BFS（广度优先遍历）
weixin_42638946的博客
03-16 1783
BFS（广度优先遍历） 1. BFS原理 原理 使用BFS可以求解最短路径，前提是：所有边的权值均相同。 使用队列完成BFS，在遍历的过程中，每次将队首的元素弹出，然后再将该队首相邻的且未被遍历的数据插入队尾，直到队列为空停止。 BFS可以解决的问题： （1）Floodfill：参考网址 （2）最短路问题 （3）多源BFS问题 （4）最小步数问题 （5）双端队列广搜 （6）双向广搜 （7）A* 这里只讲解后六种类型。 BFS求最短路的正确性证明： 我们需要证明任意时刻队列中的数据具有
BFS.rar_bfs
09-22
BFS变度量算法，.............用于工程中的数值计算
bfs.zip_bfs
09-24
数据结构里的bfs算法，用vc6.0编写
BFSK.zip_BFSK
09-24
BFSK Constellation, Symbol error rate
BFS.cpp.zip_bfs
09-24
BFS algorithm on graphs
bfs_mex.rar_bfs
09-19
bfs FGFJF KDLFLF LFLMLFMF
bfs.rar_Boost_bfs
09-20
利用boost库实现广度优先算法的例子,实现了广度优先算法，对boost的理解有用
BFS.zip_bfs_in
09-20
Breadth first search algorithm in C. Example are countries in Romania traversals.
bfs python
最新发布
05-31
BFS是广度优先搜索，是一种用于图形数据结构的遍历算法，它从图的起点开始遍历，先访问起点相邻的所有节点，然后再依次访问这些节点相邻的未访问过的节点，以此类推，直到遍历完整个图。 在Python中，我们可以使用...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值