BFS总结

能够用 BFS 解决的问题，一定不要用 DFS 去做

因为用 Recursion 实现的 DFS 可能造成 StackOverflow

(NonRecursion 的 DFS 一来你不会写，二来面试官也看不懂)

---

1. Queue

Java常用的队列包括如下几种：
　　　　ArrayDeque：数组存储。实现Deque接口，而Deque是Queue接口的子接口，代表双端队列（double-ended queue）。
　　　　LinkedList：链表存储。实现List接口和Duque接口，不仅可做队列，还可以作为双端队列，或栈（stack）来使用。

C++中，使用<queue>中的queue模板类，模板需两个参数，元素类型和容器类型，元素类型必要，而容器类型可选，默认deque，可改用list（链表）类型。

Python中，使用collections.deque，双端队列

 class MyQueue:
     # 队列初始化
     def __init__(self):
         self.elements = []  # 用list存储队列元素
         self.pointer = 0    # 队头位置

     # 获取队列中元素个数
     def size(self):
         return len(self.elements)-pointer

     # 判断队列是否为空
     def empty(self):
         return self.size() == 0

     # 在队尾添加一个元素
     def add(self, e):
         self.elements.append(e)

     # 弹出队首元素，如果为空则返回None
     def poll(self):
         if self.empty():
             return None
         pointer += 1
         return self.elements[pointer-1]

---

2. 图的BFS

BFS中可能用到的HashSet（C++: unordered_map, Python: dict)

常用邻接表存储。邻接矩阵太大了...

邻接表定义：

1. 自定义的方法，更加工程化。所以在面试中如果时间不紧张题目不难的情况下，推荐使用自定义邻接表的方式。

python:

 def DirectedGraphNode:
     def __init__(self, label):
         self.label = label
         self.neighbors = []  # a list of DirectedGraphNode's
         ...
 其中 neighbors 表示和该点连通的点有哪些

Java:

 class DirectedGraphNode {
     int label;
     List<DirectedGraphNode> neighbors;
     ...
 }

2. 使用 Map 和 Set

这种方式虽然没有上面的方式更加直观和容易理解，但是在面试中比较节约代码量。

python:

 # 假设nodes为节点标签的列表:

 # 使用了Python中的dictionary comprehension语法
 adjacency_list = {x:set() for x in nodes}

 # 另一种写法
 adjacency_list = {}
 for x in nodes:
     adjacency_list[x] = set()
 其中 T 代表节点类型。通常可能是整数(Integer)。

Java:

1  Map<T, Set<T>> = new HashMap<T, HashSet<T>>();             // node -> a set of its neighbor nodes

---

3. 拓扑排序

定义

在图论中，由一个有向无环图的顶点组成的序列，当且仅当满足下列条件时，称为该图的一个拓扑排序（英语：Topological sorting）。

• 每个顶点出现且只出现一次；
• 若A在序列中排在B的前面，则在图中不存在从B到A的路径。

也可以定义为：拓扑排序是对有向无环图的顶点的一种排序，它使得如果存在一条从顶点A到顶点B的路径，那么在排序中B出现在A的后面。

(来自 Wiki)

实际运用

拓扑排序 Topological Sorting 是一个经典的图论问题。他实际的运用中，拓扑排序可以做如下的一些事情：

• 检测编译时的循环依赖
• 制定有依赖关系的任务的执行顺序

拓扑排序不是一种排序算法

虽然名字里有 Sorting，但是相比起我们熟知的 Bubble Sort, Quick Sort 等算法，Topological Sorting 并不是一种严格意义上的 Sorting Algorithm。

确切的说，一张图的拓扑序列可以有很多个，也可能没有。拓扑排序只需要找到其中一个序列，无需找到所有序列。

入度与出度

在介绍算法之前，我们先介绍图论中的一个基本概念，入度和出度，英文为 in-degree & out-degree。
在有向图中，如果存在一条有向边 A-->B，那么我们认为这条边为 A 增加了一个出度，为 B 增加了一个入度。

算法流程

拓扑排序的算法是典型的宽度优先搜索算法，其大致流程如下：

1. 统计所有点的入度，并初始化拓扑序列为空。
2. 将所有入度为 0 的点，也就是那些没有任何依赖的点，放到宽度优先搜索的队列中
3. 将队列中的点一个一个的释放出来，放到拓扑序列中，每次释放出某个点 A 的时候，就访问 A 的相邻点（所有A指向的点），并把这些点的入度减去 1。
4. 如果发现某个点的入度被减去 1 之后变成了 0，则放入队列中。
5. 直到队列为空时，算法结束，

深度优先搜索的拓扑排序

深度优先搜索也可以做拓扑排序，不过因为不容易理解，也并不推荐作为拓扑排序的主流算法。

eg:    http://www.lintcode.com/problem/topological-sorting/    http://www.jiuzhang.com/solutions/topological-sorting/

 public class Solution {
     /**
      * @param graph: A list of Directed graph node
      * @return: Any topological order for the given graph.
      */
     public ArrayList<DirectedGraphNode> topSort(ArrayList<DirectedGraphNode> graph) {
         // map 用来存储所有节点的入度，这里主要统计各个点的入度
         HashMap<DirectedGraphNode, Integer> map = new HashMap();
         for (DirectedGraphNode node : graph) {
             for (DirectedGraphNode neighbor : node.neighbors) {
                 if (map.containsKey(neighbor)) {
                     map.put(neighbor, map.get(neighbor) + 1);
                 } else {
                     map.put(neighbor, 1);
                 }
             }
         }

         // 初始化拓扑序列为空
         ArrayList<DirectedGraphNode> result = new ArrayList<DirectedGraphNode>();

         // 把所有入度为0的点，放到BFS专用的队列中
         Queue<DirectedGraphNode> q = new LinkedList<DirectedGraphNode>();
         for (DirectedGraphNode node : graph) {
             if (!map.containsKey(node)) {
                 q.offer(node);
                 result.add(node);
             }
         }

         // 每次从队列中拿出一个点放到拓扑序列里，并将该点指向的所有点的入度减1
         while (!q.isEmpty()) {
             DirectedGraphNode node = q.poll();
             for (DirectedGraphNode n : node.neighbors) {
                 map.put(n, map.get(n) - 1);
                 // 减去1之后入度变为0的点，也放入队列
                 if (map.get(n) == 0) {
                     result.add(n);
                     q.offer(n);
                 }
             }
         }

         return result;
     }
 }

模板

入度（In-degree）：
有向图（Directed Graph）中指向当前节点的点的个数（或指向当前节点的边的条数）
算法描述：
1. 统计每个点的入度
2. 将每个入度为 0 的点放入队列（Queue）中作为起始节点
3. 不断从队列中拿出一个点，去掉这个点的所有连边（指向其他点的边），其他点的相应的入度 - 1
4. 一旦发现新的入度为 0 的点，丢回队列中
拓扑排序并不是传统的排序算法
一个图可能存在多个拓扑序（Topological Order），也可能不存在任何拓扑序

拓扑排序的四种不同问法：
    求任意1个拓扑序（Topological Order）
    问是否存在拓扑序（是否可以被拓扑排序）
    求所有的拓扑序 　　　　　　　　　　     　　DFS
    求是否存在且仅存在一个拓扑序　　 　　 　　Queue中最多同时只有1个节点

http://www.lintcode.com/problem/course-schedule/

 class DirectedGraphNode{
     int id;
     ArrayList<DirectedGraphNode> neighbors;  //node->neighbor
     public DirectedGraphNode(int x){
         id=x;
         neighbors=new ArrayList<>();
     }
 }

 class Solution {
     public ArrayList<DirectedGraphNode> topSort(DirectedGraphNode[] G){
         HashMap<Integer, Integer> map = new HashMap<>();        //nodeid and their indegree
         ArrayList<DirectedGraphNode> res = new ArrayList<>();   //top sequence
         for(DirectedGraphNode node : G)
             map.put(node.id, 0);

         for(DirectedGraphNode nodex : G)
             for(DirectedGraphNode nodey : nodex.neighbors)
                 map.put(nodey.id, map.get(nodey.id)+1);

         Queue<DirectedGraphNode> Q = new LinkedList<>();
         for(DirectedGraphNode node : G){
             if(map.get(node.id)==0){
                 Q.offer(node);
                 res.add(node);
             }
         }

         while(!Q.isEmpty()){
             DirectedGraphNode head = Q.poll();
             for(DirectedGraphNode neig : head.neighbors){
                 map.put(neig.id, map.get(neig.id)-1);
                 if(map.get(neig.id)==0){
                     Q.offer(neig);
                     res.add(neig);
                 }
             }
         }

         return(res);
     }

     public boolean canFinish(int numCourses, int[][] prerequisites) {
         DirectedGraphNode[] G = new DirectedGraphNode[numCourses];
         for(int i=0;i<numCourses;i++)
             G[i] = new DirectedGraphNode(i);

         for(int[] pairs : prerequisites){
             int x=pairs[0];
             int y=pairs[1];
             G[x].neighbors.add(G[y]);
         }

         ArrayList<DirectedGraphNode> topseq = topSort(G);
         if(topseq.size()<numCourses)
             return false;
         else
             return true;
     }
 }

http://www.lintcode.com/problem/course-schedule-ii/

 class DirectedGraphNode{
     int id;
     ArrayList<DirectedGraphNode> neighbors;  //node->neighbor
     public DirectedGraphNode(int x){
         id=x;
         neighbors=new ArrayList<>();
     }
 }

 class Solution {
     public ArrayList<DirectedGraphNode> topSort(DirectedGraphNode[] G){
         HashMap<Integer, Integer> map = new HashMap<>();        //nodeid and their indegree
         ArrayList<DirectedGraphNode> res = new ArrayList<>();   //top sequence
         for(DirectedGraphNode node : G)
             map.put(node.id, 0);

         for(DirectedGraphNode nodex : G)
             for(DirectedGraphNode nodey : nodex.neighbors)
                 map.put(nodey.id, map.get(nodey.id)+1);

         Queue<DirectedGraphNode> Q = new LinkedList<>();
         for(DirectedGraphNode node : G){
             if(map.get(node.id)==0){
                 Q.offer(node);
                 res.add(node);
             }
         }

         while(!Q.isEmpty()){
             DirectedGraphNode head = Q.poll();
             for(DirectedGraphNode neig : head.neighbors){
                 map.put(neig.id, map.get(neig.id)-1);
                 if(map.get(neig.id)==0){
                     Q.offer(neig);
                     res.add(neig);
                 }
             }
         }

         return(res);
     }

     public int[] findOrder(int numCourses, int[][] prerequisites) {
         DirectedGraphNode[] G = new DirectedGraphNode[numCourses];
         for(int i=0;i<numCourses;i++)
             G[i] = new DirectedGraphNode(i);

         for(int[] pairs : prerequisites){
             int y=pairs[0];
             int x=pairs[1];
             G[x].neighbors.add(G[y]);
         }

         ArrayList<DirectedGraphNode> topseq = topSort(G);
         int topsize=topseq.size();
         if(topsize<numCourses){
             topsize=0;
             int[] res = new int[topsize];
             return(res);
         }

         int[] res = new int[topsize];
         int cnt=0;
         for(DirectedGraphNode node : topseq){
             res[cnt]=node.id;
             cnt+=1;
         }
         return(res);
     }
 }

http://www.lintcode.com/problem/alien-dictionary/

http://www.lintcode.com/problem/sequence-reconstruction/

---

4. BFS模板

4.1 无需分层遍历

Java:

 // T 指代任何你希望存储的类型
 Queue<T> queue = new LinkedList<>();
 Set<T> set = new HashSet<>();

 set.add(start);
 queue.offer(start);
 while (!queue.isEmpty()) {
     T head = queue.poll();
     for (T neighbor : head.neighbors) {
         if (!set.contains(neighbor)) {
             set.add(neighbor);
             queue.offer(neighbor);
         }
     }
 }

Python:

 from collections import deque

 queue = deque()
 seen = set()  #等价于Java版本中的set

 seen.add(start)
 queue.append(start)
 while len(queue):
     head = queue.popleft()
     for neighbor in head.neighbors:
         if neighbor not in seen:
             seen.add(neighbor)
             queue.append(neighbor)

c++:

 queue<T> que;
 unordered_set<T, Hasher> seen;

 seen.insert(start);
 que.push(start);
 while (!que.empty()) {
   const T &head = que.front();
   que.pop();
   for (const T &neighbor : head.neighbors) {
     if (!seen.count(neighbor)) {
       seen.insert(neighbor);
       que.push(neighbor);
     }
   }
 }

• neighbor 表示从某个点 head 出发，可以走到的下一层的节点。
• set/seen 存储已经访问过的节点（已经丢到 queue 里去过的节点）
• queue 存储等待被拓展到下一层的节点
• set/seen 与 queue 是一对好基友，无时无刻都一起出现，往 queue 里新增一个节点，就要同时丢到 set 里

4.2 需要分层遍历（始终保证queue中的所有元素都来自同一层，比如binary-tree-level-order-traversal）

Java:

 // T 指代任何你希望存储的类型
 Queue<T> queue = new LinkedList<>();
 Set<T> set = new HashSet<>();

 set.add(start);
 queue.offer(start);
 while (!queue.isEmpty()) {
     int size = queue.size();
     for (int i = 0; i < size; i++) {
         T head = queue.poll();
         for (T neighbor : head.neighbors) {
             if (!set.contains(neighbor)) {
                 set.add(neighbor);
                 queue.offer(neighbor);
             }
         }
     }
 }

Python:

 from collections import deque

 queue = deque()
 seen = set()

 seen.add(start)
 queue.append(start)
 while len(queue):
     size = len(queue)
     for _ in range(size):
         head = queue.popleft()
         for neighbor in head.neighbors:
             if neighbor not in seen:
                 seen.add(neighbor)
                 queue.append(neighbor)

C++:

 queue<T> que;
 unordered_set<T, Hasher> seen;

 seen.insert(start);
 que.push(start);
 while (!que.empty()) {
   int size = que.size();
   for (int i = ; i < size; ++i) {
     const T &head = que.front();
     que.pop();
     for (const T &neighbor : head.neighbors) {
       if (!seen.count(neighbor)) {
         seen.insert(neighbor);
         que.push(neighbor);
       }
     }
   }
 }

• size = queue.size() 是一个必须的步骤。如果在 for 循环中使用 for (int i = 0; i < queue.size(); i++) 会出错，因为 queue.size() 是一个动态变化的值。所以必须先把当前层一共有多少个节点存在局部变量 size 中，才不会把下一层的节点也在当前层进行扩展。

---

1. 二叉树上的BFS

http://www.lintcode.com/problem/binary-tree-level-order-traversal/ 　　Video 11:00
https://leetcode.com/problems/binary-tree-level-order-traversal/

水题...

 /**
  * 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>> levelOrder(TreeNode root) {
         Queue<TreeNode> Q = new LinkedList<>();
         Set<TreeNode> S = new HashSet<>();
         List<List<Integer>> ans = new ArrayList<>();
         if(root==null)
             return(ans);

         S.add(root);
         Q.offer(root);
         while(!Q.isEmpty()){
             List<Integer> CurrentLevel=new ArrayList<>();
             int qsize=Q.size();
             for(int i=0;i<qsize;i++){
                 TreeNode qhead=Q.poll();
                 CurrentLevel.add(qhead.val);
                 if(qhead.left!=null){
                     S.add(qhead.left);
                     Q.offer(qhead.left);
                 }
                 if(qhead.right!=null){
                     S.add(qhead.right);
                     Q.offer(qhead.right);
                 }
             }
             ans.add(CurrentLevel);
         }
         return(ans);
     }
 }

---

2. Binary Tree的序列化/反序列化

http://www.lintcode.com/en/help/binary-tree-representation/
http://www.lintcode.com/en/problem/binary-tree-serialization/

Binary Tree Level Order Traversal II
http://www.lintcode.com/en/problem/binary-tree-level-order-traversal-ii/
http://www.jiuzhang.com/solutions/binary-tree-level-order-traversal-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) {
         List<List<Integer>> ans=new ArrayList<>();
         Queue<TreeNode> Q=new LinkedList<>();
         if(root==null)
             return(ans);
         Q.offer(root);
         while(!Q.isEmpty()){
             int qsize=Q.size();
             List<Integer> CurrentLevel=new ArrayList<>();
             for(int i=0;i<qsize;i++){
                 TreeNode qhead=Q.poll();
                 CurrentLevel.add(qhead.val);
                 if(qhead.left!=null)
                     Q.add(qhead.left);
                 if(qhead.right!=null)
                     Q.add(qhead.right);
             }
             ans.add(CurrentLevel);
         }
         for (int i = 0, j = ans.size() - 1; i < j; i++)
             ans.add(i, ans.remove(j));
         return(ans);
     }
 }

把binary-tree-level-order-traversal的结果反过来就行了...

注意一个in-place的reverse list的小技巧

Binary Tree Zigzag Order Traversal
http://www.lintcode.com/en/problem/binary-tree-zigzag-level-order-traversal/
http://www.jiuzhang.com/solutions/binary-tree-zigzag-level-order-traversal/

把binary-tree-level-order-traversal的结果胡搞一下就行了...

 /**
  * 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) {
         Queue<TreeNode> Q=new LinkedList<>();
         List<List<Integer>> ans=new ArrayList<>();

         if(root==null)
             return(ans);

         boolean seq=true;   //true: l->r    false: r->l
         Q.offer(root);
         while(!Q.isEmpty()){
             int qsize=Q.size();
             List<Integer> CurrentLevel=new ArrayList<>();
             for(int i=0;i<qsize;i++){
                 TreeNode qhead=Q.poll();
                 CurrentLevel.add(qhead.val);
                 if(qhead.left!=null)
                     Q.add(qhead.left);
                 if(qhead.right!=null)
                     Q.add(qhead.right);
             }
             if(seq)
                 seq=false;
             else{
                 for(int i=0;i<CurrentLevel.size()/2;i++){
                     int j=CurrentLevel.size()-i-1;
                     int tmp=CurrentLevel.get(i);
                     CurrentLevel.set(i, CurrentLevel.get(j));
                     CurrentLevel.set(j,tmp);
                 }
                 seq=true;
             }
             ans.add(CurrentLevel);
         }

         return(ans);
     }
 }

Convert Binary Tree to Linked Lists by Depth
http://www.lintcode.com/en/problem/convert-binary-tree-to-linked-lists-by-depth/
http://www.jiuzhang.com/solutions/convert-binary-tree-to-linked-lists-by-depth/

把binary-tree-level-order-traversal的结果建个链表就行了

 /**
  * Definition of TreeNode:
  * public class TreeNode {
  *     public int val;
  *     public TreeNode left, right;
  *     public TreeNode(int val) {
  *         this.val = val;
  *         this.left = this.right = null;
  *     }
  * }
  * Definition for singly-linked list.
  * public class ListNode {
  *     int val;
  *     ListNode next;
  *     ListNode(int x) { val = x; }
  * }
  */
 public class Solution {
     /**
      * @param root the root of binary tree
      * @return a lists of linked list
      */
     public List<ListNode> binaryTreeToLists(TreeNode root) {
         // Write your code here
         List<ListNode> ans=new ArrayList<>();
         Queue<TreeNode> Q=new LinkedList<>();
         if(root==null)
             return(ans);

         Q.offer(root);
         while(!Q.isEmpty()){
             int qsize=Q.size();
             TreeNode qhead=Q.poll();
             ListNode lhead=new ListNode(qhead.val);
             lhead.next=null;
             ListNode lpnt=lhead;
             if(qhead.left!=null)
                 Q.offer(qhead.left);
             if(qhead.right!=null)
                 Q.offer(qhead.right);
             for(int i=0;i<qsize-1;i++){
                 qhead=Q.poll();
                 ListNode ltmp=new ListNode(qhead.val);
                 lpnt.next=ltmp;
                 lpnt=lpnt.next;
                 if(qhead.left!=null)
                     Q.offer(qhead.left);
                 if(qhead.right!=null)
                     Q.offer(qhead.right);
             }
             ans.add(lhead);
         }

         return(ans);
     }
 }

---

3. 图的BFS

http://www.lintcode.com/problem/clone-graph/ 　　Video 43:00

http://www.lintcode.com/problem/word-ladder/ 　　Video  55:00

 class Solution {
     public int distance(String A, String B){
         int sl=A.length();
         int ans=0;
         for(int i=0;i<sl;i++){
             if(A.charAt(i)!=B.charAt(i))
                 ans++;
         }
         return(ans);
     }

     public int ladderLength(String beginWord, String endWord, List<String> wordList) {
         Queue<String> Q=new LinkedList<>();
         Map<String, Integer> S=new HashMap<>();

         Q.offer(beginWord);
         S.put(beginWord, 1);

         while(!Q.isEmpty()){
             String qhead=Q.poll();
             int dep=S.get(qhead);
             if(qhead.equals(endWord))
                 return(dep);
             for(String dictword : wordList){
                 if(distance(qhead, dictword)==1 && !S.containsKey(dictword)){
                     S.put(dictword, dep+1);
                     Q.offer(dictword);
                 }
             }
         }

         return(0);
     }
 }

图上的BFS

判断一个图是否是一棵树
http://www.lintcode.com/problem/graph-valid-tree/

搜索图中最近值为target的点
http://www.lintcode.com/problem/search-graph-nodes/

无向图联通块
http://www.lintcode.com/problem/connected-component-in-undirected-graph

序列重构（判断是否只有一个拓扑排序）

http://www.lintcode.com/problem/sequence-reconstruction/

---

4. 矩阵的bfs

图 Graph
N个点，M条边
M最大是 O(N^) 的级别
图上BFS时间复杂度 = O(N + M)
• 说是O(M)问题也不大，因为M一般都比N大
所以最坏情况可能是 O(N^)

矩阵 Matrix
R行C列
R*C个点，R*C* 条边（每个点上下左右4条边，每条边被2个点共享）。
矩阵中BFS时间复杂度 = O(R * C)

http://www.lintcode.com/problem/number-of-islands/ 　　Video 1:30:00

偷懒用dfs做了....

 class Solution {
     public boolean[][] visited;

     public void dfs(int x,int y,char[][] grid){
         int lx=grid.length;
         int ly=grid[0].length;
         int[] dx={1,0,-1,0};
         int[] dy={0,1,0,-1};

         for(int i=0;i<4;i++){
             int tx=x+dx[i];
             int ty=y+dy[i];
             if(tx>=0 && tx<lx && ty>=0 && ty<ly)
                 if(!visited[tx][ty] && grid[tx][ty]=='1'){
                     visited[tx][ty]=true;
                     dfs(tx,ty,grid);
                 }
         }
     }

     public int numIslands(char[][] grid) {
         int lx=grid.length;
         if(lx==0)
             return(0);
         int ly=grid[0].length;
         int ans=0;
         visited=new boolean[lx][ly];

         for(int i=0;i<lx;i++){
             for(int j=0;j<ly;j++){
                 if(grid[i][j]=='1' && !visited[i][j]){
                     ans+=1;
                     visited[i][j]=true;
                     dfs(i,j,grid);
                 }
             }
         }

         return(ans);
     }
 }

http://www.lintcode.com/problem/knight-shortest-path/ 　　Video 1:35:00

矩阵上的BFS
僵尸多少天吃掉所有人
http://www.lintcode.com/problem/zombie-in-matrix/

建邮局问题 Build Post Office II
http://www.lintcode.com/problem/build-post-office-ii/

---

双向BFS

双向宽度优先搜索 (Bidirectional BFS) 算法适用于如下的场景：

1. 无向图
2. 所有边的长度都为 1 或者长度都一样
3. 同时给出了起点和终点

以上 3 个条件都满足的时候，可以使用双向宽度优先搜索来求出起点和终点的最短距离。

双向宽度优先搜索本质上还是BFS，只不过变成了起点向终点和终点向起点同时进行扩展，直至两个方向上出现同一个子节点，搜索结束。

我们还是可以利用队列来实现：一个队列保存从起点开始搜索的状态，另一个保存从终点开始的状态，两边如果相交了，那么搜索结束。起点到终点的最短距离即为起点到相交节点的距离与终点到相交节点的距离之和。

Q.双向BFS是否真的能提高效率？
假设单向BFS需要搜索 N 层才能到达终点，每层的判断量为 X，那么总的运算量为 X ^ N. 如果换成是双向BFS，前后各自需要搜索 N / 2 层，总运算量为 2∗X^(N/2)。

如果 N 比较大且X 不为 1，则运算量相较于单向BFS可以大大减少，差不多可以减少到原来规模的根号的量级。

Bidirectional BFS 掌握起来并不是很难，算法实现上稍微复杂了一点（代码量相对单向 BFS 翻倍），掌握这个算法一方面加深对普通 BFS 的熟练程度，另外一方面，基本上写一次就能记住，如果在面试中被问到了如何优化 BFS 的问题，Bidirectional BFS 几乎就是标准答案了。

https://www.jiuzhang.com/tutorial/algorithm/371

 /**
  * Definition for graph node.
  * class UndirectedGraphNode {
  *     int label;
  *     ArrayList<UndirectedGraphNode> neighbors;
  *     UndirectedGraphNode(int x) {
  *         label = x; neighbors = new ArrayList<UndirectedGraphNode>();
  *     }
  * };
  */
 public int doubleBFS(UndirectedGraphNode start, UndirectedGraphNode end) {
     if (start.equals(end)) {
         return 1;
     }
     // 起点开始的BFS队列
     Queue<UndirectedGraphNode> startQueue = new LinkedList<>();
     // 终点开始的BFS队列
     Queue<UndirectedGraphNode> endQueue = new LinkedList<>();
     startQueue.add(start);
     endQueue.add(end);
     int step = 0;
     // 记录从起点开始访问到的节点
     Set<UndirectedGraphNode> startVisited = new HashSet<>();
     // 记录从终点开始访问到的节点
     Set<UndirectedGraphNode> endVisited = new HashSet<>();
     startVisited.add(start);
     endVisited.add(end);
     while (!startQueue.isEmpty() || !endQueue.isEmpty()) {
         int startSize = startQueue.size();
         int endSize = endQueue.size();
         // 按层遍历
         step ++;
         for (int i = 0; i < startSize; i ++) {
             UndirectedGraphNode cur = startQueue.poll();
             for (UndirectedGraphNode neighbor : cur.neighbors) {
                 if (startVisited.contains(neighbor)) {//重复节点
                     continue;
                 } else if (endVisited.contains(neighbor)) {//相交
                     return step;
                 } else {
                     startVisited.add(neighbor);
                     startQueue.add(neighbor);
                 }
             }
         }
         step ++;
         for (int i = 0; i < endSize; i ++) {
             UndirectedGraphNode cur = endQueue.poll();
             for (UndirectedGraphNode neighbor : cur.neighbors) {
                 if (endVisited.contains(neighbor)) {
                     continue;
                 } else if (startVisited.contains(neighbor)) {
                     return step;
                 } else {
                     endVisited.add(neighbor);
                     endQueue.add(neighbor);
                 }
             }
         }
     }
     return -1; // 不连通
 }

http://www.lintcode.com/zh-cn/problem/shortest-path-in-undirected-graph/

http://www.lintcode.com/zh-cn/problem/knight-shortest-path/

http://www.lintcode.com/en/problem/knight-shortest-path-ii/

---

Appendix:

使用两个队列的BFS实现

我们可以将当前层的所有节点存在第一个队列中，然后拓展（Extend）出的下一层节点存在另外一个队列中。来回迭代，逐层展开。

 // T 表示任意你想存储的类型
 Queue<T> queue1 = new LinkedList<>();
 Queue<T> queue2 = new LinkedList<>();
 queue1.offer(startNode);
 int currentLevel = 0;

 while (!queue1.isEmpty()) {
    int size = queue1.size();
     for (int i = 0; i < size; i++) {
         T head = queue1.poll();
         for (all neighbors of head) {
             queue2.offer(neighbor);
         }
     }
     Queue<T> temp = queue1;
     queue1 = queue2;
     queue2 = temp;

     queue2.clear();
     currentLevel++;
 }

使用 Dummy Node 进行 BFS

什么是 Dummy Node

Dummy Node，翻译为哨兵节点。Dummy Node 一般本身不存储任何实际有意义的值，通常用作"占位"，或者链表的“虚拟头”。
如很多的链表问题中，我们会在原来的头head的前面新增一个节点，这个节点没有任何值，但是 next 指向 head。这样就会方便对 head 进行删除或者在前面插入等操作。

head->node->node->node ...
=>
dummy->head->node->node->node...

Dummy Node 在 BFS 中如何使用

在 BFS 中，我们主要用 dummy node 来做占位符。即，在队列中每一层节点的结尾，都放一个 null（or None in Python，nil in Ruby），来表示这一层的遍历结束了。这里 dummy node 就是一个 null。

 // T 可以是任何你想存储的节点的类型
 Queue<T> queue = new LinkedList<>();
 queue.offer(startNode);
 queue.offer(null);
 currentLevel = 0;
 // 因为有 dummy node 的存在，不能再用 isEmpty 了来判断是否还有没有拓展的节点了
 while (queue.size() > 1) {
     T head = queue.poll();
     if (head == null) {
         currentLevel++;
         queue.offer(null);
         continue;
     }
     for (all neighbors of head) {
         queue.offer(neighbor);
     }
 }