深度優先搜索檢測有向圖有無環路算法

給定有向圖 G = (V, E)，需要判斷該圖中是否存在環路（Cycle）。例如，下面的圖 G 中包含 4 個頂點和 6 條邊。

實際上，上圖中存在 3 個環路：0->2->0, 0->1->2->0, 3->3。

深度優先搜索（DFS：Depth-First Search）可以用於檢測圖中是否存在環。DFS 會對一個連通的圖構造一顆樹，如果在構造樹的過程中出現反向邊（Back Edge），則認為圖中存在環路。

對於非連通圖，可以對圖中的不同部分分別進行 DFS 構造樹結構，對於每棵樹分別檢測反向邊的存在。

在 DFS 對圖進行遍歷時，將遍歷過的頂點放入遞歸棧中，如果新遍歷的頂點已經存在於遞歸棧中，則說明存在一個反向邊，即存在一個環。

using System;
using System.Collections.Generic;
using System.Linq;

namespace GraphAlgorithmTesting
{
  class Program
  {
    static void Main(string[] args)
    {
      Graph g = new Graph(6);
      g.AddEdge(0, 1, 16);
      g.AddEdge(0, 2, 13);
      g.AddEdge(1, 2, 10);
      g.AddEdge(1, 3, 12);
      g.AddEdge(2, 1, 4);
      g.AddEdge(2, 4, 14);
      //g.AddEdge(3, 2, 9);
      g.AddEdge(3, 5, 20);
      //g.AddEdge(4, 3, 7);
      //g.AddEdge(4, 5, 4);

      Console.WriteLine();
      Console.WriteLine("Graph Vertex Count : {0}", g.VertexCount);
      Console.WriteLine("Graph Edge Count : {0}", g.EdgeCount);
      Console.WriteLine();

      Console.WriteLine("Is there cycle in graph: {0}", g.HasCycle());

      Console.ReadKey();
    }

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

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

      public override string ToString()
      {
        return string.Format(
          "Begin[{0}], End[{1}], Weight[{2}]",
          Begin, End, Weight);
      }
    }

    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 IEnumerable<int> Vertices { get { return _adjacentEdges.Keys; } }

      public IEnumerable<Edge> Edges
      {
        get { return _adjacentEdges.Values.SelectMany(e => e); }
      }

      public int EdgeCount { get { return this.Edges.Count(); } }

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

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

      public bool HasCycle()
      {
        // mark all the vertices as not visited 
        // and not part of recursion stack
        bool[] visited = new bool[VertexCount];
        bool[] recursionStack = new bool[VertexCount];
        for (int i = 0; i < VertexCount; i++)
        {
          visited[i] = false;
          recursionStack[i] = false;
        }

        // call the recursive helper function to 
        // detect cycle in different DFS trees
        for (int i = 0; i < VertexCount; i++)
          if (CheckCyclic(i, visited, recursionStack))
            return true;

        return false;
      }

      private bool CheckCyclic(int v, bool[] visited, bool[] recursionStack)
      {
        if (!visited[v])
        {
          // mark the current node as visited 
          // and part of recursion stack
          visited[v] = true;
          recursionStack[v] = true;

          // recur for all the vertices adjacent to this vertex
          if (_adjacentEdges.ContainsKey(v))
          {
            foreach (var edge in _adjacentEdges[v])
            {
              if (!visited[edge.End]
                && CheckCyclic(edge.End, visited, recursionStack))
                return true;
              else if (recursionStack[edge.End])
                return true;
            }
          }
        }

        // remove the vertex from recursion stack
        recursionStack[v] = false;

        return false;
      }
    }
  }
}

本篇文章《DFS 檢測有向圖有無環算法》由 Dennis Gao 發表自博客園，未經作者本人同意禁止任何形式的轉載，任何自動或人為的爬蟲轉載行為均為耍流氓。