算法学习-广度优先遍历（单源BFS、多源BFS、双向BFS）

互联网民工蒋大钊

已于 2023-04-22 16:15:24 修改

阅读量1.1k

点赞数

分类专栏：算法人生文章标签：算法学习宽度优先

于 2022-08-25 15:03:45 首次发布

本文链接：https://blog.csdn.net/qq_44036439/article/details/126520393

版权

算法人生专栏收录该内容

48 篇文章 3 订阅

订阅专栏

广度优先遍历和深度优先遍历是图论中两大重要的算法，但是他们并不是只用于图，在树以及其他题目中都有重要的应用，因此我觉得值得笔者好好进行总结。

参考文献：

负雪明烛大佬的模板
 甜姨就图BFS和树DFS的分析
 负雪明烛BFS和DFS的区别
 liweiwei的BFS、双向BFS

基础知识

BFS常用于从一个点出发求「最短距离」的题目，适用于无权有向图，可以有环，其与DFS的区别如下所示：
在这里插入图片描述
这种无权的最短路算法需要和其他加权有向图的最短路算法进行区分，参考我的另一篇文章算法学习-最短路算法与各种存图方式。

多源BFS

简单地说就是在最开始进队的时候进入多个，在统计和层数相关的问题时，实际上是把第一次进队的多个都一视同仁了，在层数上将它们都看作0。后面需要转换思想，灵活选择合适的节点（0或者1）进队，如542.01矩阵。

//单源BFS进一个，多源BFS进多个，默认标记访问
queue.offer(node)

双向BFS

已知BFS起点和终点的情况下，可以分别从起点和目标顶点（终点）执行广度优先遍历，直到遍历的部分有交集，这样子可以减少从一边开始搜索的时候，随着层数的增加，搜索空间变大的情况。

每次选择从节点数较小的一边开始向外扩散，交替扩散直到出现交集，两边扩散的时候都对一个全局的level 进行++，同时在return时看队列是否出现交集。
在这里插入图片描述

相关题目

图相关

1162.地图分析

层数相关的多源BFS+求最短距离最大值。也就是求所有陆地与某个海洋最近距离的最大值，即刚开始会在队列中放入多个陆地，一圈一圈地去遍历海洋。每圈的BFS就记录了当前所有陆地与海洋的最短距离，要找到最大的，我们只需要一直找到que.isEmpty()没有节点可以加入，那个时候distance一定是某个点到出发点的最远距离。这里在入队时就进行有效判断以及访问标记。

class Solution {
    public int maxDistance(int[][] grid) {
        int[]dx=new int[]{0,1,0,-1};
        int[]dy=new int[]{1,0,-1,0};
        ArrayDeque<int[]> que=new ArrayDeque<>();
        int m=grid.length;
        int n=grid[0].length;
        for(int i=0;i<m;i++){
            for(int j=0;j<n;j++){
                if(grid[i][j]==1){
                    que.offer(new int[]{i,j});
                }
            }
        }
        //全是陆地或者海洋特判
        if(que.size()==0||que.size()==m*n) return -1;

        //刚开始distance默认为-1，陆地出队的时候+1变为0，最后一个出队也会加一次
        // distance已走路径两个端点都算了一遍，所以刚开始取-1抵消一次，最后距离只算一个端点
        int distance=-1;
        while(!que.isEmpty()){
            int size=que.size();
            distance++;
            while(size-->0){
                int[] top=que.poll();
                for(int i=0;i<4;i++){
                    int x=top[0]+dx[i];
                    int y=top[1]+dy[i];
                    //入队时进行有效判断
                    if(x<0||x>=m||y<0||y>=n||grid[x][y]!=0) continue;
                    //入队进行标记访问
                    grid[x][y]++;
                    
                    que.offer(new int[]{x,y});
                }
            }
        }
        return distance;
    }
}

934.最短的桥

DFS标记图+层数相关的多源BFS，不同于1162.地图分析要找到所有最短路的最大值，这里只需要存在一条最近的桥就可以了，可以在找到和当前值不同的值直接return层数。刚开始多源BFS将一座岛上的层数都看为0，在向外扩张的时候相当于是一层一层往外移动，找到最近的另一座岛上的节点就返回。

class Solution:
    def shortestBridge(self, grid: List[List[int]]) -> int:
        que=deque()
        def dfs(grid,i,j,mark):
            if i<0 or i>=len(grid) or j<0 or j>=len(grid[0]):
                return
            if grid[i][j] != 1:
                return
            grid[i][j]=mark
            que.append((i,j))
            dfs(grid,i+1,j,mark)
            dfs(grid,i-1,j,mark)
            dfs(grid,i,j-1,mark)
            dfs(grid,i,j+1,mark)

        find=0
        for i in range (len(grid)):
            for j in range(len(grid[0])):
                if grid[i][j]==1 and find==0:
                    dfs(grid,i,j,2)
                    find +=1
                    
        # BFS 找最短路径
        distance =-1
        while len(que)!=0:
            distance +=1
            size = len(que)
            for _ in range(size):
                top=que.popleft()
                dx=[0,1,0,-1]
                dy=[1,0,-1,0]
                for k in range(4):
                    i,j=top[0]+dx[k],top[1]+dy[k]
                    if i<0 or i>=len(grid) or j<0 or j>=len(grid[0]):
                        continue
                    if grid[i][j] == 2:
                        continue
                    # 直接return 结果，已走路径的两个端点都不算
                    if grid[i][j] == 1:
                        return distance
                    grid[i][j]=2
                    que.append((i,j))
        return distance

2385.感染二叉树需要的总时间

DFS建图+BFS模板二，由于是无向图，而不是从根到叶子节点有方向的树，可能会出现已访问节点被重复访问的可能，所以得做好标记「不要重复访问」，数组标记或者Set标记都可以，这里选择在入队时就标记。

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    HashMap<Integer,HashSet<Integer>> map;
    public int amountOfTime(TreeNode root, int start) {
        map=new HashMap<>();
        buildGraph(root);
        HashSet<Integer> vis=new HashSet<>();
        Deque<Integer> que=new ArrayDeque<>();
        que.offer(start);
        vis.add(start);
        int res=-1;
        while(!que.isEmpty()){
            res++;
            int size=que.size();
            for(int i=0;i<size;i++){
                int top=que.poll();
                HashSet<Integer>set=map.get(top);
                if(set==null) continue;
                for(int node:set){
                    //不重复访问
                    if(vis.contains(node)) continue;
                    vis.add(node);
                    que.offer(node);
                }
            }
        }
        return res;
    }


    public void buildGraph(TreeNode root){
        if(root==null) return;
        if(root.left!=null){
            HashSet<Integer> set1=map.getOrDefault(root.val,new HashSet<Integer>());
            HashSet<Integer> set2=map.getOrDefault(root.left.val,new HashSet<Integer>());
            set1.add(root.left.val);
            set2.add(root.val);
            map.put(root.val,set1);
            map.put(root.left.val,set2);
        }
        if(root.right!=null){
            HashSet<Integer> set1=map.getOrDefault(root.val,new HashSet<Integer>());
            HashSet<Integer> set2=map.getOrDefault(root.right.val,new HashSet<Integer>());
            set1.add(root.right.val);
            set2.add(root.val);
            map.put(root.val,set1);
            map.put(root.right.val,set2);
        }
        buildGraph(root.left);
        buildGraph(root.right);
    }
}

310.最小高度树

容器并统计入度信息建立无向图+多源BFS模板一，只需要找到最小高度树的节点，而不需要求出最小高度。可以观察到，从叶子节点往里找，可以找到最小高度树，只需要记录最后一轮BFS的节点就是最小高度树的根节点。建图过程中统计了入度信息，不用额外标记访问。

class Solution {
    public List<Integer> findMinHeightTrees(int n, int[][] edges) {
        //特殊判断一个节点
        if(n==1) return Arrays.asList(0);
        //容器建立无向图邻接图
        HashSet<Integer>[] map=new HashSet[n];
        int[] inDegree=new int[n];
        for(int i=0;i<n;i++){
            map[i]=new HashSet<Integer>();
        }
        //建立无向图，两个节点都有一个度
        for(int[]e:edges){
            map[e[0]].add(e[1]);
            map[e[1]].add(e[0]);
            inDegree[e[0]]++;
            inDegree[e[1]]++;
        }
        
        Deque<Integer> que=new ArrayDeque<>();
        //无向图只有一个度入队
        for(int i=0;i<n;i++){
            if(inDegree[i]==1) que.offer(i);
        }

        //记录下最后一圈出队列的数字就是根
        ArrayList<Integer> ans=new ArrayList<>();
        while(!que.isEmpty()){
            ans.clear();
            int size=que.size();
            for(int i=0;i<size;i++){
                int top=que.poll();
                ans.add(top);
                for(int node:map[top]){
                    if(--inDegree[node]==1) que.offer(node);
                }
            }
        }
        return ans;
    }
}

2359.找到离给定两个节点最近的节点

无权图有环，可以尝试BFS求最短路算法，而不用小题大做用其他有权图算法。采用距离数组-1做访问判断，距离按圈数增加+1。

class Solution {
    public int closestMeetingNode(int[] edges, int node1, int node2) {
        int len=edges.length;
        int[] dis1=new int[len];
        int[] dis2=new int[len];
        Arrays.fill(dis1,-1);
        Arrays.fill(dis2,-1);
        bfs(node1,edges,dis1);
        bfs(node2,edges,dis2);
        int minDis=len;
        int index=-1;
        for(int i=0;i<len;i++){
            if(dis1[i]==-1||dis2[i]==-1) continue;
            int maxD=Math.max(dis1[i],dis2[i]);
            if(maxD<minDis){
                minDis=maxD;
                index=i;
            }
        }
        return index;
    }

    public void bfs(int node,int[]edges,int[]dis){
        ArrayDeque<Integer> que=new ArrayDeque<>();
        que.offer(node);
        dis[node]=0;
        int cur=0;
        while(!que.isEmpty()){
            int size=que.size();
            cur++;
            for(int i=0;i<size;i++){
                int top=que.poll();
                if(edges[top]!=-1&&dis[edges[top]]==-1){
                    dis[edges[top]]=cur;
                    que.offer(edges[top]);
                }
            }
        }
    }
}

这道题目给的是内向基环树，可以采用一个循环求最短路径的方法，

class Solution {
    public int closestMeetingNode(int[] edges, int node1, int node2) {
        int len=edges.length;
        int[] dis1=new int[len];
        int[] dis2=new int[len];
        Arrays.fill(dis1,-1);
        Arrays.fill(dis2,-1);
        bfs(node1,edges,dis1);
        bfs(node2,edges,dis2);
        int minDis=len;
        //不存在返回-1
        int index=-1;
        for(int i=0;i<len;i++){
            if(dis1[i]==-1||dis2[i]==-1) continue;
            int maxD=Math.max(dis1[i],dis2[i]);
            if(maxD<minDis){
                minDis=maxD;
                index=i;
            }
        }
        return index;
    }

    public void bfs(int node,int[]edges,int[]dis){
        //在不是最后一个点以及有环的情况下一直算dis
        for(int d=0;node!=-1&&dis[node]==-1;node=edges[node]){
            dis[node]=d++;
        }
    }
}

542.01矩阵

和层数相关的多源BFS，求1到0的最近距离，这里转换思想，将所有0一视同仁，反而求所有0到最近的1的距离。distance初始化为0，因为节点在进队前就判断是否为1赋值了，已走路径只算了一个端点。

class Solution:
    def updateMatrix(self, mat: List[List[int]]) -> List[List[int]]:
        q=deque()
        res=[[0]*len(mat[0]) for _ in range(len(mat))]
        for i in range(len(mat)):
            for j in range(len(mat[0])):
                if mat[i][j]==0:
                    mat[i][j]=-1
                    q.append((i,j))
        #初始化为0，是因为后面进队之前就赋值了
        distance=0
        while q:
            size=len(q)
            distance +=1
            for i in range(size):
                top= q.popleft()
                topx=top[0]
                topy=top[1]
                dx=[0,1,0,-1]
                dy=[1,0,-1,0]
                for k in range(4):
                    x=topx+dx[k]
                    y=topy+dy[k]
                    if x<0 or x>=len(mat) or y<0 or y>=len(mat[0]) or mat[x][y]==-1:
                        continue
                    # 进队之前就赋值
                    if mat[x][y]==1:
                        res[x][y]=distance
                    mat[x][y]=-1
                    q.append((x,y))
        return res

和层数有关的单源BFS+状态压缩。通过BFS找最短距离，节点在进入队列的时候，拥有(nx,ny,pnewstatus)坐标x，坐标y和当前已经有的钥匙pnewstatus，通过位运算状态压缩的方法记录手上已经有的钥匙，在拓展节点的时候，需要根据拓展节点的性质能否开锁看是否需要加入队列，如果有新的钥匙则需要改变原来的状态，否则都是旧的钥匙状态延续下去。这里在加入节点的时候，可以前面先将所有不符合条件的节点排除，最后再加入未被访问过的节点。

class Solution:
    def shortestPathAllKeys(self, grid: List[str]) -> int:
        q=deque()
        vis=set()
        dir=[(0,1),(0,-1),(1,0),(-1,0)]
        n,m,cnt=len(grid),len(grid[0]),0
        for i in range(n):
            for j in range(m):
                if grid[i][j]=='@':
                    q.append((i,j,0))
                    vis.add((i,j,0))
                if 'a'<=grid[i][j]<='z':
                    cnt +=1
        
        level=0
        while q:
            level +=1
            size = len(q)
            for _ in range(size):
                top=q.popleft()
                px,py,pstatus=top[0],top[1],top[2]
                for d in range(len(dir)):
                    nx=px+dir[d][0]
                    ny=py+dir[d][1]
                    if nx<0 or nx>=n or ny<0 or ny>=m:
                        continue

                    # 记录下一步的状态
                    pnewstatus=pstatus
                    c=grid[nx][ny]
                    if c=='#':
                        continue
                    if 'A'<=c<='Z' and pstatus>>(ord(c)-ord('A'))&1==0:
                        continue
                    if 'a'<=c<='z':
                         pnewstatus=pstatus|1<<(ord(c)-ord('a'))
                    # 所有连续的钥匙都已经找到
                    if (1<<cnt)-1==pnewstatus:
                        return level
                    # 最后将符合搜索条件的节点加入队列中
                    if (nx,ny,pnewstatus) not in vis:
                             q.append((nx,ny,pnewstatus))
                             vis.add((nx,ny,pnewstatus))
        return -1

树相关

43.往完全二叉树添加节点

采用和搜索层数无关的广度优先搜索，找到某个节点的左节点或者右节点为空，则将新节点插入到其左节点或者右节点上。后面的查询可以从该点开始查，不需要每次重新入队，将前面已经出队列的点再入队一次，因此可以将该点放入队头。

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class CBTInserter {
    TreeNode root;
    ArrayDeque<TreeNode> que;
    public CBTInserter(TreeNode _root) {
        root=_root;
        que=new ArrayDeque<>();
    }
    
    public int insert(int v) {
        TreeNode newNode=new TreeNode(v);
        que.offer(root);
        while(!que.isEmpty()){
            TreeNode top=que.poll();
            if(top.left==null){
                top.left=newNode;
                que.offerFirst(top);
            }else if(top.right==null){
                top.right=newNode;
                que.offerFirst(top);
            }else{
                que.offer(top.left);
                que.offer(top.right);
                continue;
            }
            return top.val;
        }
        return -1;
    }
    
    public TreeNode get_root() {
        return root;
    }
}

/**
 * Your CBTInserter object will be instantiated and called as such:
 * CBTInserter obj = new CBTInserter(root);
 * int param_1 = obj.insert(v);
 * TreeNode param_2 = obj.get_root();
 */

44.二叉树每层的最大值

经典层序遍历

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public List<Integer> largestValues(TreeNode root) {
        ArrayList<Integer> ans=new ArrayList<>();
        if(root==null) return ans;
        Deque<TreeNode> que=new LinkedList<>();
        que.offer(root);
        while(!que.isEmpty()){
            int size=que.size();
            int maxV=Integer.MIN_VALUE;
            for(int i=0;i<size;i++){
                TreeNode top=que.poll();
                maxV=Math.max(maxV,top.val);
                if(top.left!=null) que.offer(top.left);
                if(top.right!=null) que.offer(top.right);
            }
            ans.add(maxV);
        }
        return ans;
    }
}

45.二叉树最底层最左边的值

同样是层次遍历，记录最后一层最左边的数字，只需要用一个局部变量ans每次都更新为最左边的数字，最后就是最后一层最左边的数字。

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public int findBottomLeftValue(TreeNode root) {
        Deque<TreeNode> que=new ArrayDeque<>();
        que.offer(root);
        int ans=-1;
        while(!que.isEmpty()){
            int size=que.size();
            for(int i=0;i<size;i++){
                TreeNode top=que.poll();
                if(i==0) ans=top.val;
                if(top.left!=null) que.offer(top.left);
                if(top.right!=null) que.offer(top.right);
            }
        }
        return ans;
    }
}

46.二叉树的右侧视图

经典层次遍历

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public List<Integer> rightSideView(TreeNode root) {
        Deque<TreeNode> que=new ArrayDeque<>();
        ArrayList<Integer> ans=new ArrayList<>();
        if(root==null) return ans;
        que.offer(root);
        while(!que.isEmpty()){
            int size=que.size();
            for(int i=0;i<size;i++){
                TreeNode top=que.poll();
                if(i==size-1) ans.add(top.val);
                if(top.left!=null) que.offer(top.left);
                if(top.right!=null) que.offer(top.right);
            }
        } 
        return ans;
    }
}

二维平面上的搜索问题

这个类型的题目我在我的另一篇文章算法学习-深度优先遍历也进行了总结，有些题目广度优先遍历也可以解答。

抽象成广度优先搜索

127.单词接龙

层数相关的BFS+求最短距离。将单词的改变序列抽象为BFS一层层地扩散，扩散的机制为只改变原序列的一个字母并且改变后的字母在wordList中，先用哈希表将wordList单词存起来，通过对单词一位的26个字母不断枚举，判断新的单词是否在该哈希表中，如果不存在则忽略，如果存在则看其是否为最终单词。在这个过程中用set标记已经被访问过的单词，防止有环形成重复访问。这题起点和终点都确定，也可以用双向BFS解答。

class Solution:
    def ladderLength(self, beginWord: str, endWord: str, wordList: List[str]) -> int:
        wordset=set(wordList)
        # 合法的单词序列
        if beginWord in wordset:
            wordset.remove(beginWord)
        q=deque()
        vis=set()
        q.append(beginWord)
        vis.add(beginWord)

        level=0
        while q:
            level +=1
            size=len(q)
            # 针对每个单词
            for _ in range(size):
                top=q.popleft()
                # 枚举其每一位上26个字母的可能性
                listword=list(top)
                for i,c in enumerate(top):
                    for k in range(26):
                        listword[i]=chr(ord('a')+k)
                        nextword=''.join(listword)
                        # 在合法的单词序列中
                        if nextword in wordset:
                            # 下一个单词就是终点词
                            if nextword == endWord:
                                return level+1
                            # 下一个单词不是终点次且没有被访问
                            if nextword not in vis:
                                vis.add(nextword)
                                q.append(nextword)
                    # 将当前被替换位复原
                    listword[i]=c
        
        return 0

752.打开转盘锁

类似127.单词接龙，这里有需要在deadends以外的情况中选择，同时每次只能旋转一次+1，-1改变一次。需要考虑更多的特殊情况，beginword可能就是endword，beginword可能就在dendends中。

class Solution:
    def openLock(self, deadends: List[str], target: str) -> int:
        # 特殊情况考虑
        if '0000'in deadends:
            return -1
        if '0000' == target:
            return 0
        deadset=set(deadends)
        q=collections.deque()
        vis=set()
        vis.add('0000')
        q.append('0000')
        level=-1
        while q:
            level +=1
            size=len(q)
            # 所有可行元素逐层出队
            for _ in range(size):
                top=q.popleft()
                listword=list(top)
                # 针对一个word的所有位置上的元素
                for i,c in enumerate(listword):
                    # 该位置上的两种情况枚举
                    for k in {1,-1}:
                        listword[i]=str((int(c)+k+10)%10)
                        nextword=''.join(listword)
                        # 当nextword不在deadset中时
                        if nextword not in deadset:
                            if nextword==target:
                                return level +1
                            if nextword not in vis: 
                                q.append(nextword)
                                vis.add(nextword)
                    # 回溯还原，避免对下一次枚举产生影响
                    listword[i]=c
        return -1