Union-Find 检测无向图有无环路算法

不相交集合数据结构（Disjoint-set data structure）是一种用于跟踪集合被分割成多个不相交的子集合的数据结构，每个集合通过一个代表来标识，代表即集合中的某个成员。

Union-Find 算法为该数据结构提供了两种非常有用的操作：

• Find：判断子集中是否存在特定的元素。可以用于检测是否两个元素存在于相同的子集中。
• Union：将两个不子集合并成新的子集合。

Union-Find 算法的一个具体的应用就是在无向图（Undirected Graph）中检测是否存在环路（Cycle）。

例如，下面这张无向图 G：

0
| 
|   
1-----2

G 中包含 3 个顶点和 3 条边 {{0, 1}, {1, 2}, {2, 1}}。

初始时，设 int[] parent = new int[VertexCount]，默认每个顶点的子集中只有自己，设为 -1。

0   1  2
-1 -1 -1

处理边 {0, 1}，Find 顶点 0 和 1 的子集，发现它们在不同的子集中，则 Union 它们，此时 1 代表了子集 {0, 1}。

0  1  2
1 -1 -1

处理边 {1, 2}，Find 顶点 1 和 2 的子集，发现它们在不同的子集中，则 Union 它们，此时 2 代表了子集 {0, 1, 2}。

0 1  2
1 2 -1

处理边 {2, 1}，Find 顶点 2 和 1 的子集，发现它们在相同的子集中，则图存在环。

Union-Find 算法简单实现如下，其时间复杂度为 O(n)。

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));
      }

      private int Find(int[] parent, int i)
      {
        if (parent[i] == -1)
          return i;
        return Find(parent, parent[i]);
      }

      private void Union(int[] parent, int x, int y)
      {
        int xset = Find(parent, x);
        int yset = Find(parent, y);
        parent[xset] = yset;
      }

      public bool HasCycle()
      {
        int[] parent = new int[VertexCount];
        for (int i = 0; i < parent.Length; i++)
        {
          parent[i] = -1;
        }

        // Iterate through all edges of graph, find subset of both
        // vertices of every edge, if both subsets are same, 
        // then there is cycle in graph.
        foreach (var edge in this.Edges)
        {
          int x = Find(parent, edge.Begin);
          int y = Find(parent, edge.End);

          if (x == y)
          {
            return true;
          }

          Union(parent, x, y);
        }

        return false;
      }
    }
  }
}

本篇文章《Union-Find 检测无向图有无环路算法》由 Dennis Gao 发表自博客园，未经作者本人同意禁止任何形式的转载，任何自动或人为的爬虫转载行为均为耍流氓。