不相交集合森林的启发式策略

在文章《Union-Find 操作检测无向图有无环算法》中介绍了 Union-Find 算法的一个简单实现，使用一维数组来处理不相交集合数据结构（Disjoint-set data structure）。

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

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

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

上述算法的实现的运行时间是 O(n)。

另一种实现方式是使用有根树来表示集合，树中的每个节点都包含集合的一个成员，每棵树表示一个集合，形成不相交集合森林（Disjoint-set forest）。每棵树的根包含了集合的代表，并且是它自己的父节点。

如上图中，(a) 中两棵树表示两个集合 {b, c, e, h} 和 {d, f, g}，其中 c 和 f 是代表。(b) 为 Union(e, g) 的结果。

实际上，上面这种树的表示法不会比采用链表表示的算法更快。但是，通过引入两种启发式策略，可以获得目前已知的、渐进意义上最快的不想交集合数据结构。

• 第一种启发式策略是按秩合并（Union by Rank），其思想是使包含较少节点的树的根指向包含较多节点的树的根。
• 第二种启发式策略是路径压缩（Path Compression），在 Find 操作中，使查找路径上的每个节点都直接指向根节点。路径压缩并不改变节点的秩（Rank）。

如上图中，(a) 为执行 Find 操作之前的表示集合的树；(b) 为执行 Find(a) 操作后的树，查找路径上的每个节点都直接指向了根。

通过两种启发式策略对运行时间的改进，新的算法的运行时间为 O(logn)。

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 Subset
    {
      public int Parent { get; set; }
      public int Rank { get; 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 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(Subset[] subsets, int i)
      {
        // find root and make root as parent of i (path compression)
        if (subsets[i].Parent != i)
          subsets[i].Parent = Find(subsets, subsets[i].Parent);

        return subsets[i].Parent;
      }

      private void Union(Subset[] subsets, int x, int y)
      {
        int xroot = Find(subsets, x);
        int yroot = Find(subsets, y);

        // Attach smaller rank tree under root of high rank tree
        // (Union by Rank)
        if (subsets[xroot].Rank < subsets[yroot].Rank)
          subsets[xroot].Parent = yroot;
        else if (subsets[xroot].Rank > subsets[yroot].Rank)
          subsets[yroot].Parent = xroot;

        // If ranks are same, then make one as root and increment
        // its rank by one
        else
        {
          subsets[yroot].Parent = xroot;
          subsets[xroot].Rank++;
        }
      }

      public bool HasCycle()
      {
        Subset[] subsets = new Subset[VertexCount];
        for (int i = 0; i < subsets.Length; i++)
        {
          subsets[i] = new Subset();
          subsets[i].Parent = i;
          subsets[i].Rank = 0;
        }

        // 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(subsets, edge.Begin);
          int y = Find(subsets, edge.End);

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

          Union(subsets, x, y);
        }

        return false;
      }
    }
  }
}

本篇文章《不相交集合森林的启发式策略》由 Dennis Gao 发表自博客园，未经作者本人同意禁止任何形式的转载，任何自动或人为的爬虫转载行为均为耍流氓。