廣度優先搜索

廣度優先搜索（BFS：Breadth-First Search）是一種圖搜索策略，其將搜索限制到 2 種操作：

• (a) 訪問圖中的一個節點；
• (b) 訪問該節點的鄰居節點；

廣度優先搜索（BFS）由 Edward F. Moore 在 1950 年發表，起初被用於在迷宮中尋找最短路徑。在 Prim 最小生成樹算法和 Dijkstra 單源最短路徑算法中，都采用了與廣度優先搜索類似的思想。

對圖的廣度優先搜索與對樹（Tree）的廣度優先遍歷（Breadth First Traversal）是類似的，區別在於圖中可能存在環，所以可能會遍歷到已經遍歷的節點。BFD 算法首先會發現和源頂點 s 距離邊數為 k 的所有頂點，然后才會發現和 s 距離邊數為 k+1 的其他頂點。

例如，下面的圖中，從頂點 2 開始遍歷，當遍歷到頂點 0 時，鄰接的頂點為 1 和 2，而頂點 2 已經遍歷過，如果不做標記，遍歷過程將陷入死循環。所以，在 BFS 的算法實現中需要對頂點是否訪問過做標記。

上圖的 BFS 遍歷結果為 [ 2, 0, 3, 1 ]。

BFS 算法的實現通常使用隊列（Queue）數據結構來存儲遍歷圖中節點的中間狀態，過程如下：

1. 將 root 節點 Enqueue；
2. Dequeue 一個節點，並檢查該節點：
   • 如果該節點就是要找的目標節點，則結束遍歷，返回結果 "Found"；
   • 否則，Enqueue 所有直接后繼子節點（如果節點未被訪問過）；
3. 如果 Queue 為空，並且圖中的所有節點都被檢查過，仍未找到目標節點，則結束搜索，返回結果 "Not Found"；
4. 如果 Queue 不為空，重復步驟 2；

如果需要記錄搜索的軌跡，可以為頂點着色。起初所有頂點為白色，隨着搜索的進行變為灰色，然后變成黑色。灰色和黑色頂點都是已發現的頂點。

BFS 算法偽碼如下：

procedure BFS(G,v) is
    create a queue Q
    create a set V
    add v to V
    enqueue v onto Q
    while Q is not empty loop
       t = Q.dequeue()
       if t is what we are looking for then
          return t
       end if
       for all edges e in G.adjacentEdges(t) loop
          u = G.adjacentVertex(t,e)
          if u is not in V then
              add u to V
              enqueue u onto Q
          end if
       end loop
    end loop
    return none
end BFS

廣度優先搜索（BFS）的時間復雜度為 O(V+E)，V 即 Vertex 頂點數量，E 即 Edge 邊數量。

BFS 算法實現代碼如下：

using System;
using System.Collections.Generic;

namespace GraphAlgorithmTesting
{
  class Program
  {
    static void Main(string[] args)
    {
      Graph g = new Graph(4);
      g.AddEdge(0, 1);
      g.AddEdge(0, 2);
      g.AddEdge(1, 2);
      g.AddEdge(2, 0);
      g.AddEdge(2, 3);
      g.AddEdge(3, 3);

      List<int> traversal = g.BFS(2);
      foreach (var vertex in traversal)
      {
        Console.WriteLine(vertex);
      }

      Console.ReadKey();
    }

    class Edge
    {
      public Edge(int begin, int end)
      {
        this.Begin = begin;
        this.End = end;
      }

      public int Begin { get; private set; }
      public int End { get; private set; }
    }

    class Graph
    {
      private Dictionary<int, List<Edge>> _adjacentEdges
        = new Dictionary<int, List<Edge>>();

      public Graph(int vertexCount)
      {
        this.VertexCount = vertexCount;
      }

      public int VertexCount { get; private set; }

      public void AddEdge(int begin, int end)
      {
        if (!_adjacentEdges.ContainsKey(begin))
        {
          var edges = new List<Edge>();
          _adjacentEdges.Add(begin, edges);
        }

        _adjacentEdges[begin].Add(new Edge(begin, end));
      }

      public List<int> BFS(int start)
      {
        List<int> traversal = new List<int>();
        int current = start;

        // mark all the vertices as not visited
        bool[] visited = new bool[VertexCount];
        for (int i = 0; i < VertexCount; i++)
        {
          visited[i] = false;
        }

        // create a queue for BFS
        Queue<int> queue = new Queue<int>();

        // mark the current node as visited and enqueue it
        visited[current] = true;
        queue.Enqueue(current);

        while (queue.Count > 0)
        {
          current = queue.Dequeue();

          // if this is what we are looking for
          traversal.Add(current);

          // get all adjacent vertices of the dequeued vertex,
          // if a adjacent has not been visited, 
          // then mark it visited and enqueue it
          if (_adjacentEdges.ContainsKey(current))
          {
            foreach (var edge in _adjacentEdges[current])
            {
              if (!visited[edge.End])
              {
                visited[edge.End] = true;
                queue.Enqueue(edge.End);
              }
            }
          }
        }

        return traversal;
      }
    }
  }
}

參考資料

• 廣度優先搜索
• 深度優先搜索
• Breadth First Traversal for a Graph
• Depth First Traversal for a Graph
• Introduction to Algorithms 6.006 - Lecture 13

本篇文章《廣度優先搜索》由 Dennis Gao 發表自博客園，未經作者本人同意禁止任何形式的轉載，任何自動或人為的爬蟲轉載行為均為耍流氓。