lemon/unionfind.h
author Alpar Juttner <alpar@cs.elte.hu>
Mon, 14 Jul 2008 15:40:24 +0100
changeset 217 b67149f0e675
parent 103 b68a7e348e00
child 220 a5d8c039f218
permissions -rw-r--r--
Merge
     1 /* -*- mode: C++; indent-tabs-mode: nil; -*-
     2  *
     3  * This file is a part of LEMON, a generic C++ optimization library.
     4  *
     5  * Copyright (C) 2003-2008
     6  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
     7  * (Egervary Research Group on Combinatorial Optimization, EGRES).
     8  *
     9  * Permission to use, modify and distribute this software is granted
    10  * provided that this copyright notice appears in all copies. For
    11  * precise terms see the accompanying LICENSE file.
    12  *
    13  * This software is provided "AS IS" with no warranty of any kind,
    14  * express or implied, and with no claim as to its suitability for any
    15  * purpose.
    16  *
    17  */
    18 
    19 #ifndef LEMON_UNION_FIND_H
    20 #define LEMON_UNION_FIND_H
    21 
    22 //!\ingroup auxdat
    23 //!\file
    24 //!\brief Union-Find data structures.
    25 //!
    26 
    27 #include <vector>
    28 #include <list>
    29 #include <utility>
    30 #include <algorithm>
    31 #include <functional>
    32 
    33 #include <lemon/bits/invalid.h>
    34 
    35 namespace lemon {
    36 
    37   /// \ingroup auxdat
    38   ///
    39   /// \brief A \e Union-Find data structure implementation
    40   ///
    41   /// The class implements the \e Union-Find data structure.
    42   /// The union operation uses rank heuristic, while
    43   /// the find operation uses path compression.
    44   /// This is a very simple but efficient implementation, providing
    45   /// only four methods: join (union), find, insert and size.
    46   /// For more features see the \ref UnionFindEnum class.
    47   ///
    48   /// It is primarily used in Kruskal algorithm for finding minimal
    49   /// cost spanning tree in a graph.
    50   /// \sa kruskal()
    51   ///
    52   /// \pre You need to add all the elements by the \ref insert()
    53   /// method.
    54   template <typename _ItemIntMap>
    55   class UnionFind {
    56   public:
    57 
    58     typedef _ItemIntMap ItemIntMap;
    59     typedef typename ItemIntMap::Key Item;
    60 
    61   private:
    62     // If the items vector stores negative value for an item then
    63     // that item is root item and it has -items[it] component size.
    64     // Else the items[it] contains the index of the parent.
    65     std::vector<int> items;
    66     ItemIntMap& index;
    67 
    68     bool rep(int idx) const {
    69       return items[idx] < 0;
    70     }
    71 
    72     int repIndex(int idx) const {
    73       int k = idx;
    74       while (!rep(k)) {
    75         k = items[k] ;
    76       }
    77       while (idx != k) {
    78         int next = items[idx];
    79         const_cast<int&>(items[idx]) = k;
    80         idx = next;
    81       }
    82       return k;
    83     }
    84 
    85   public:
    86 
    87     /// \brief Constructor
    88     ///
    89     /// Constructor of the UnionFind class. You should give an item to
    90     /// integer map which will be used from the data structure. If you
    91     /// modify directly this map that may cause segmentation fault,
    92     /// invalid data structure, or infinite loop when you use again
    93     /// the union-find.
    94     UnionFind(ItemIntMap& m) : index(m) {}
    95 
    96     /// \brief Returns the index of the element's component.
    97     ///
    98     /// The method returns the index of the element's component.
    99     /// This is an integer between zero and the number of inserted elements.
   100     ///
   101     int find(const Item& a) {
   102       return repIndex(index[a]);
   103     }
   104 
   105     /// \brief Clears the union-find data structure
   106     ///
   107     /// Erase each item from the data structure.
   108     void clear() {
   109       items.clear();
   110     }
   111 
   112     /// \brief Inserts a new element into the structure.
   113     ///
   114     /// This method inserts a new element into the data structure.
   115     ///
   116     /// The method returns the index of the new component.
   117     int insert(const Item& a) {
   118       int n = items.size();
   119       items.push_back(-1);
   120       index.set(a,n);
   121       return n;
   122     }
   123 
   124     /// \brief Joining the components of element \e a and element \e b.
   125     ///
   126     /// This is the \e union operation of the Union-Find structure.
   127     /// Joins the component of element \e a and component of
   128     /// element \e b. If \e a and \e b are in the same component then
   129     /// it returns false otherwise it returns true.
   130     bool join(const Item& a, const Item& b) {
   131       int ka = repIndex(index[a]);
   132       int kb = repIndex(index[b]);
   133 
   134       if ( ka == kb )
   135         return false;
   136 
   137       if (items[ka] < items[kb]) {
   138         items[ka] += items[kb];
   139         items[kb] = ka;
   140       } else {
   141         items[kb] += items[ka];
   142         items[ka] = kb;
   143       }
   144       return true;
   145     }
   146 
   147     /// \brief Returns the size of the component of element \e a.
   148     ///
   149     /// Returns the size of the component of element \e a.
   150     int size(const Item& a) {
   151       int k = repIndex(index[a]);
   152       return - items[k];
   153     }
   154 
   155   };
   156 
   157   /// \ingroup auxdat
   158   ///
   159   /// \brief A \e Union-Find data structure implementation which
   160   /// is able to enumerate the components.
   161   ///
   162   /// The class implements a \e Union-Find data structure
   163   /// which is able to enumerate the components and the items in
   164   /// a component. If you don't need this feature then perhaps it's
   165   /// better to use the \ref UnionFind class which is more efficient.
   166   ///
   167   /// The union operation uses rank heuristic, while
   168   /// the find operation uses path compression.
   169   ///
   170   /// \pre You need to add all the elements by the \ref insert()
   171   /// method.
   172   ///
   173   template <typename _ItemIntMap>
   174   class UnionFindEnum {
   175   public:
   176 
   177     typedef _ItemIntMap ItemIntMap;
   178     typedef typename ItemIntMap::Key Item;
   179 
   180   private:
   181 
   182     ItemIntMap& index;
   183 
   184     // If the parent stores negative value for an item then that item
   185     // is root item and it has ~(items[it].parent) component id.  Else
   186     // the items[it].parent contains the index of the parent.
   187     //
   188     // The \c next and \c prev provides the double-linked
   189     // cyclic list of one component's items.
   190     struct ItemT {
   191       int parent;
   192       Item item;
   193 
   194       int next, prev;
   195     };
   196 
   197     std::vector<ItemT> items;
   198     int firstFreeItem;
   199 
   200     struct ClassT {
   201       int size;
   202       int firstItem;
   203       int next, prev;
   204     };
   205 
   206     std::vector<ClassT> classes;
   207     int firstClass, firstFreeClass;
   208 
   209     int newClass() {
   210       if (firstFreeClass == -1) {
   211         int cdx = classes.size();
   212         classes.push_back(ClassT());
   213         return cdx;
   214       } else {
   215         int cdx = firstFreeClass;
   216         firstFreeClass = classes[firstFreeClass].next;
   217         return cdx;
   218       }
   219     }
   220 
   221     int newItem() {
   222       if (firstFreeItem == -1) {
   223         int idx = items.size();
   224         items.push_back(ItemT());
   225         return idx;
   226       } else {
   227         int idx = firstFreeItem;
   228         firstFreeItem = items[firstFreeItem].next;
   229         return idx;
   230       }
   231     }
   232 
   233 
   234     bool rep(int idx) const {
   235       return items[idx].parent < 0;
   236     }
   237 
   238     int repIndex(int idx) const {
   239       int k = idx;
   240       while (!rep(k)) {
   241         k = items[k].parent;
   242       }
   243       while (idx != k) {
   244         int next = items[idx].parent;
   245         const_cast<int&>(items[idx].parent) = k;
   246         idx = next;
   247       }
   248       return k;
   249     }
   250 
   251     int classIndex(int idx) const {
   252       return ~(items[repIndex(idx)].parent);
   253     }
   254 
   255     void singletonItem(int idx) {
   256       items[idx].next = idx;
   257       items[idx].prev = idx;
   258     }
   259 
   260     void laceItem(int idx, int rdx) {
   261       items[idx].prev = rdx;
   262       items[idx].next = items[rdx].next;
   263       items[items[rdx].next].prev = idx;
   264       items[rdx].next = idx;
   265     }
   266 
   267     void unlaceItem(int idx) {
   268       items[items[idx].prev].next = items[idx].next;
   269       items[items[idx].next].prev = items[idx].prev;
   270 
   271       items[idx].next = firstFreeItem;
   272       firstFreeItem = idx;
   273     }
   274 
   275     void spliceItems(int ak, int bk) {
   276       items[items[ak].prev].next = bk;
   277       items[items[bk].prev].next = ak;
   278       int tmp = items[ak].prev;
   279       items[ak].prev = items[bk].prev;
   280       items[bk].prev = tmp;
   281 
   282     }
   283 
   284     void laceClass(int cls) {
   285       if (firstClass != -1) {
   286         classes[firstClass].prev = cls;
   287       }
   288       classes[cls].next = firstClass;
   289       classes[cls].prev = -1;
   290       firstClass = cls;
   291     }
   292 
   293     void unlaceClass(int cls) {
   294       if (classes[cls].prev != -1) {
   295         classes[classes[cls].prev].next = classes[cls].next;
   296       } else {
   297         firstClass = classes[cls].next;
   298       }
   299       if (classes[cls].next != -1) {
   300         classes[classes[cls].next].prev = classes[cls].prev;
   301       }
   302 
   303       classes[cls].next = firstFreeClass;
   304       firstFreeClass = cls;
   305     }
   306 
   307   public:
   308 
   309     UnionFindEnum(ItemIntMap& _index)
   310       : index(_index), items(), firstFreeItem(-1),
   311         firstClass(-1), firstFreeClass(-1) {}
   312 
   313     /// \brief Inserts the given element into a new component.
   314     ///
   315     /// This method creates a new component consisting only of the
   316     /// given element.
   317     ///
   318     int insert(const Item& item) {
   319       int idx = newItem();
   320 
   321       index.set(item, idx);
   322 
   323       singletonItem(idx);
   324       items[idx].item = item;
   325 
   326       int cdx = newClass();
   327 
   328       items[idx].parent = ~cdx;
   329 
   330       laceClass(cdx);
   331       classes[cdx].size = 1;
   332       classes[cdx].firstItem = idx;
   333 
   334       firstClass = cdx;
   335 
   336       return cdx;
   337     }
   338 
   339     /// \brief Inserts the given element into the component of the others.
   340     ///
   341     /// This methods inserts the element \e a into the component of the
   342     /// element \e comp.
   343     void insert(const Item& item, int cls) {
   344       int rdx = classes[cls].firstItem;
   345       int idx = newItem();
   346 
   347       index.set(item, idx);
   348 
   349       laceItem(idx, rdx);
   350 
   351       items[idx].item = item;
   352       items[idx].parent = rdx;
   353 
   354       ++classes[~(items[rdx].parent)].size;
   355     }
   356 
   357     /// \brief Clears the union-find data structure
   358     ///
   359     /// Erase each item from the data structure.
   360     void clear() {
   361       items.clear();
   362       firstClass = -1;
   363       firstFreeItem = -1;
   364     }
   365 
   366     /// \brief Finds the component of the given element.
   367     ///
   368     /// The method returns the component id of the given element.
   369     int find(const Item &item) const {
   370       return ~(items[repIndex(index[item])].parent);
   371     }
   372 
   373     /// \brief Joining the component of element \e a and element \e b.
   374     ///
   375     /// This is the \e union operation of the Union-Find structure.
   376     /// Joins the component of element \e a and component of
   377     /// element \e b. If \e a and \e b are in the same component then
   378     /// returns -1 else returns the remaining class.
   379     int join(const Item& a, const Item& b) {
   380 
   381       int ak = repIndex(index[a]);
   382       int bk = repIndex(index[b]);
   383 
   384       if (ak == bk) {
   385         return -1;
   386       }
   387 
   388       int acx = ~(items[ak].parent);
   389       int bcx = ~(items[bk].parent);
   390 
   391       int rcx;
   392 
   393       if (classes[acx].size > classes[bcx].size) {
   394         classes[acx].size += classes[bcx].size;
   395         items[bk].parent = ak;
   396         unlaceClass(bcx);
   397         rcx = acx;
   398       } else {
   399         classes[bcx].size += classes[acx].size;
   400         items[ak].parent = bk;
   401         unlaceClass(acx);
   402         rcx = bcx;
   403       }
   404       spliceItems(ak, bk);
   405 
   406       return rcx;
   407     }
   408 
   409     /// \brief Returns the size of the class.
   410     ///
   411     /// Returns the size of the class.
   412     int size(int cls) const {
   413       return classes[cls].size;
   414     }
   415 
   416     /// \brief Splits up the component.
   417     ///
   418     /// Splitting the component into singleton components (component
   419     /// of size one).
   420     void split(int cls) {
   421       int fdx = classes[cls].firstItem;
   422       int idx = items[fdx].next;
   423       while (idx != fdx) {
   424         int next = items[idx].next;
   425 
   426         singletonItem(idx);
   427 
   428         int cdx = newClass();
   429         items[idx].parent = ~cdx;
   430 
   431         laceClass(cdx);
   432         classes[cdx].size = 1;
   433         classes[cdx].firstItem = idx;
   434 
   435         idx = next;
   436       }
   437 
   438       items[idx].prev = idx;
   439       items[idx].next = idx;
   440 
   441       classes[~(items[idx].parent)].size = 1;
   442 
   443     }
   444 
   445     /// \brief Removes the given element from the structure.
   446     ///
   447     /// Removes the element from its component and if the component becomes
   448     /// empty then removes that component from the component list.
   449     ///
   450     /// \warning It is an error to remove an element which is not in
   451     /// the structure.
   452     /// \warning This running time of this operation is proportional to the
   453     /// number of the items in this class.
   454     void erase(const Item& item) {
   455       int idx = index[item];
   456       int fdx = items[idx].next;
   457 
   458       int cdx = classIndex(idx);
   459       if (idx == fdx) {
   460         unlaceClass(cdx);
   461         items[idx].next = firstFreeItem;
   462         firstFreeItem = idx;
   463         return;
   464       } else {
   465         classes[cdx].firstItem = fdx;
   466         --classes[cdx].size;
   467         items[fdx].parent = ~cdx;
   468 
   469         unlaceItem(idx);
   470         idx = items[fdx].next;
   471         while (idx != fdx) {
   472           items[idx].parent = fdx;
   473           idx = items[idx].next;
   474         }
   475 
   476       }
   477 
   478     }
   479 
   480     /// \brief Gives back a representant item of the component.
   481     ///
   482     /// Gives back a representant item of the component.
   483     Item item(int cls) const {
   484       return items[classes[cls].firstItem].item;
   485     }
   486 
   487     /// \brief Removes the component of the given element from the structure.
   488     ///
   489     /// Removes the component of the given element from the structure.
   490     ///
   491     /// \warning It is an error to give an element which is not in the
   492     /// structure.
   493     void eraseClass(int cls) {
   494       int fdx = classes[cls].firstItem;
   495       unlaceClass(cls);
   496       items[items[fdx].prev].next = firstFreeItem;
   497       firstFreeItem = fdx;
   498     }
   499 
   500     /// \brief Lemon style iterator for the representant items.
   501     ///
   502     /// ClassIt is a lemon style iterator for the components. It iterates
   503     /// on the ids of the classes.
   504     class ClassIt {
   505     public:
   506       /// \brief Constructor of the iterator
   507       ///
   508       /// Constructor of the iterator
   509       ClassIt(const UnionFindEnum& ufe) : unionFind(&ufe) {
   510         cdx = unionFind->firstClass;
   511       }
   512 
   513       /// \brief Constructor to get invalid iterator
   514       ///
   515       /// Constructor to get invalid iterator
   516       ClassIt(Invalid) : unionFind(0), cdx(-1) {}
   517 
   518       /// \brief Increment operator
   519       ///
   520       /// It steps to the next representant item.
   521       ClassIt& operator++() {
   522         cdx = unionFind->classes[cdx].next;
   523         return *this;
   524       }
   525 
   526       /// \brief Conversion operator
   527       ///
   528       /// It converts the iterator to the current representant item.
   529       operator int() const {
   530         return cdx;
   531       }
   532 
   533       /// \brief Equality operator
   534       ///
   535       /// Equality operator
   536       bool operator==(const ClassIt& i) {
   537         return i.cdx == cdx;
   538       }
   539 
   540       /// \brief Inequality operator
   541       ///
   542       /// Inequality operator
   543       bool operator!=(const ClassIt& i) {
   544         return i.cdx != cdx;
   545       }
   546 
   547     private:
   548       const UnionFindEnum* unionFind;
   549       int cdx;
   550     };
   551 
   552     /// \brief Lemon style iterator for the items of a component.
   553     ///
   554     /// ClassIt is a lemon style iterator for the components. It iterates
   555     /// on the items of a class. By example if you want to iterate on
   556     /// each items of each classes then you may write the next code.
   557     ///\code
   558     /// for (ClassIt cit(ufe); cit != INVALID; ++cit) {
   559     ///   std::cout << "Class: ";
   560     ///   for (ItemIt iit(ufe, cit); iit != INVALID; ++iit) {
   561     ///     std::cout << toString(iit) << ' ' << std::endl;
   562     ///   }
   563     ///   std::cout << std::endl;
   564     /// }
   565     ///\endcode
   566     class ItemIt {
   567     public:
   568       /// \brief Constructor of the iterator
   569       ///
   570       /// Constructor of the iterator. The iterator iterates
   571       /// on the class of the \c item.
   572       ItemIt(const UnionFindEnum& ufe, int cls) : unionFind(&ufe) {
   573         fdx = idx = unionFind->classes[cls].firstItem;
   574       }
   575 
   576       /// \brief Constructor to get invalid iterator
   577       ///
   578       /// Constructor to get invalid iterator
   579       ItemIt(Invalid) : unionFind(0), idx(-1) {}
   580 
   581       /// \brief Increment operator
   582       ///
   583       /// It steps to the next item in the class.
   584       ItemIt& operator++() {
   585         idx = unionFind->items[idx].next;
   586         if (idx == fdx) idx = -1;
   587         return *this;
   588       }
   589 
   590       /// \brief Conversion operator
   591       ///
   592       /// It converts the iterator to the current item.
   593       operator const Item&() const {
   594         return unionFind->items[idx].item;
   595       }
   596 
   597       /// \brief Equality operator
   598       ///
   599       /// Equality operator
   600       bool operator==(const ItemIt& i) {
   601         return i.idx == idx;
   602       }
   603 
   604       /// \brief Inequality operator
   605       ///
   606       /// Inequality operator
   607       bool operator!=(const ItemIt& i) {
   608         return i.idx != idx;
   609       }
   610 
   611     private:
   612       const UnionFindEnum* unionFind;
   613       int idx, fdx;
   614     };
   615 
   616   };
   617 
   618   /// \ingroup auxdat
   619   ///
   620   /// \brief A \e Extend-Find data structure implementation which
   621   /// is able to enumerate the components.
   622   ///
   623   /// The class implements an \e Extend-Find data structure which is
   624   /// able to enumerate the components and the items in a
   625   /// component. The data structure is a simplification of the
   626   /// Union-Find structure, and it does not allow to merge two components.
   627   ///
   628   /// \pre You need to add all the elements by the \ref insert()
   629   /// method.
   630   template <typename _ItemIntMap>
   631   class ExtendFindEnum {
   632   public:
   633 
   634     typedef _ItemIntMap ItemIntMap;
   635     typedef typename ItemIntMap::Key Item;
   636 
   637   private:
   638 
   639     ItemIntMap& index;
   640 
   641     struct ItemT {
   642       int cls;
   643       Item item;
   644       int next, prev;
   645     };
   646 
   647     std::vector<ItemT> items;
   648     int firstFreeItem;
   649 
   650     struct ClassT {
   651       int firstItem;
   652       int next, prev;
   653     };
   654 
   655     std::vector<ClassT> classes;
   656 
   657     int firstClass, firstFreeClass;
   658 
   659     int newClass() {
   660       if (firstFreeClass != -1) {
   661         int cdx = firstFreeClass;
   662         firstFreeClass = classes[cdx].next;
   663         return cdx;
   664       } else {
   665         classes.push_back(ClassT());
   666         return classes.size() - 1;
   667       }
   668     }
   669 
   670     int newItem() {
   671       if (firstFreeItem != -1) {
   672         int idx = firstFreeItem;
   673         firstFreeItem = items[idx].next;
   674         return idx;
   675       } else {
   676         items.push_back(ItemT());
   677         return items.size() - 1;
   678       }
   679     }
   680 
   681   public:
   682 
   683     /// \brief Constructor
   684     ExtendFindEnum(ItemIntMap& _index)
   685       : index(_index), items(), firstFreeItem(-1),
   686         classes(), firstClass(-1), firstFreeClass(-1) {}
   687 
   688     /// \brief Inserts the given element into a new component.
   689     ///
   690     /// This method creates a new component consisting only of the
   691     /// given element.
   692     int insert(const Item& item) {
   693       int cdx = newClass();
   694       classes[cdx].prev = -1;
   695       classes[cdx].next = firstClass;
   696       if (firstClass != -1) {
   697         classes[firstClass].prev = cdx;
   698       }
   699       firstClass = cdx;
   700 
   701       int idx = newItem();
   702       items[idx].item = item;
   703       items[idx].cls = cdx;
   704       items[idx].prev = idx;
   705       items[idx].next = idx;
   706 
   707       classes[cdx].firstItem = idx;
   708 
   709       index.set(item, idx);
   710 
   711       return cdx;
   712     }
   713 
   714     /// \brief Inserts the given element into the given component.
   715     ///
   716     /// This methods inserts the element \e item a into the \e cls class.
   717     void insert(const Item& item, int cls) {
   718       int idx = newItem();
   719       int rdx = classes[cls].firstItem;
   720       items[idx].item = item;
   721       items[idx].cls = cls;
   722 
   723       items[idx].prev = rdx;
   724       items[idx].next = items[rdx].next;
   725       items[items[rdx].next].prev = idx;
   726       items[rdx].next = idx;
   727 
   728       index.set(item, idx);
   729     }
   730 
   731     /// \brief Clears the union-find data structure
   732     ///
   733     /// Erase each item from the data structure.
   734     void clear() {
   735       items.clear();
   736       classes.clear;
   737       firstClass = firstFreeClass = firstFreeItem = -1;
   738     }
   739 
   740     /// \brief Gives back the class of the \e item.
   741     ///
   742     /// Gives back the class of the \e item.
   743     int find(const Item &item) const {
   744       return items[index[item]].cls;
   745     }
   746 
   747     /// \brief Gives back a representant item of the component.
   748     ///
   749     /// Gives back a representant item of the component.
   750     Item item(int cls) const {
   751       return items[classes[cls].firstItem].item;
   752     }
   753 
   754     /// \brief Removes the given element from the structure.
   755     ///
   756     /// Removes the element from its component and if the component becomes
   757     /// empty then removes that component from the component list.
   758     ///
   759     /// \warning It is an error to remove an element which is not in
   760     /// the structure.
   761     void erase(const Item &item) {
   762       int idx = index[item];
   763       int cdx = items[idx].cls;
   764 
   765       if (idx == items[idx].next) {
   766         if (classes[cdx].prev != -1) {
   767           classes[classes[cdx].prev].next = classes[cdx].next;
   768         } else {
   769           firstClass = classes[cdx].next;
   770         }
   771         if (classes[cdx].next != -1) {
   772           classes[classes[cdx].next].prev = classes[cdx].prev;
   773         }
   774         classes[cdx].next = firstFreeClass;
   775         firstFreeClass = cdx;
   776       } else {
   777         classes[cdx].firstItem = items[idx].next;
   778         items[items[idx].next].prev = items[idx].prev;
   779         items[items[idx].prev].next = items[idx].next;
   780       }
   781       items[idx].next = firstFreeItem;
   782       firstFreeItem = idx;
   783 
   784     }
   785 
   786 
   787     /// \brief Removes the component of the given element from the structure.
   788     ///
   789     /// Removes the component of the given element from the structure.
   790     ///
   791     /// \warning It is an error to give an element which is not in the
   792     /// structure.
   793     void eraseClass(int cdx) {
   794       int idx = classes[cdx].firstItem;
   795       items[items[idx].prev].next = firstFreeItem;
   796       firstFreeItem = idx;
   797 
   798       if (classes[cdx].prev != -1) {
   799         classes[classes[cdx].prev].next = classes[cdx].next;
   800       } else {
   801         firstClass = classes[cdx].next;
   802       }
   803       if (classes[cdx].next != -1) {
   804         classes[classes[cdx].next].prev = classes[cdx].prev;
   805       }
   806       classes[cdx].next = firstFreeClass;
   807       firstFreeClass = cdx;
   808     }
   809 
   810     /// \brief Lemon style iterator for the classes.
   811     ///
   812     /// ClassIt is a lemon style iterator for the components. It iterates
   813     /// on the ids of classes.
   814     class ClassIt {
   815     public:
   816       /// \brief Constructor of the iterator
   817       ///
   818       /// Constructor of the iterator
   819       ClassIt(const ExtendFindEnum& ufe) : extendFind(&ufe) {
   820         cdx = extendFind->firstClass;
   821       }
   822 
   823       /// \brief Constructor to get invalid iterator
   824       ///
   825       /// Constructor to get invalid iterator
   826       ClassIt(Invalid) : extendFind(0), cdx(-1) {}
   827 
   828       /// \brief Increment operator
   829       ///
   830       /// It steps to the next representant item.
   831       ClassIt& operator++() {
   832         cdx = extendFind->classes[cdx].next;
   833         return *this;
   834       }
   835 
   836       /// \brief Conversion operator
   837       ///
   838       /// It converts the iterator to the current class id.
   839       operator int() const {
   840         return cdx;
   841       }
   842 
   843       /// \brief Equality operator
   844       ///
   845       /// Equality operator
   846       bool operator==(const ClassIt& i) {
   847         return i.cdx == cdx;
   848       }
   849 
   850       /// \brief Inequality operator
   851       ///
   852       /// Inequality operator
   853       bool operator!=(const ClassIt& i) {
   854         return i.cdx != cdx;
   855       }
   856 
   857     private:
   858       const ExtendFindEnum* extendFind;
   859       int cdx;
   860     };
   861 
   862     /// \brief Lemon style iterator for the items of a component.
   863     ///
   864     /// ClassIt is a lemon style iterator for the components. It iterates
   865     /// on the items of a class. By example if you want to iterate on
   866     /// each items of each classes then you may write the next code.
   867     ///\code
   868     /// for (ClassIt cit(ufe); cit != INVALID; ++cit) {
   869     ///   std::cout << "Class: ";
   870     ///   for (ItemIt iit(ufe, cit); iit != INVALID; ++iit) {
   871     ///     std::cout << toString(iit) << ' ' << std::endl;
   872     ///   }
   873     ///   std::cout << std::endl;
   874     /// }
   875     ///\endcode
   876     class ItemIt {
   877     public:
   878       /// \brief Constructor of the iterator
   879       ///
   880       /// Constructor of the iterator. The iterator iterates
   881       /// on the class of the \c item.
   882       ItemIt(const ExtendFindEnum& ufe, int cls) : extendFind(&ufe) {
   883         fdx = idx = extendFind->classes[cls].firstItem;
   884       }
   885 
   886       /// \brief Constructor to get invalid iterator
   887       ///
   888       /// Constructor to get invalid iterator
   889       ItemIt(Invalid) : extendFind(0), idx(-1) {}
   890 
   891       /// \brief Increment operator
   892       ///
   893       /// It steps to the next item in the class.
   894       ItemIt& operator++() {
   895         idx = extendFind->items[idx].next;
   896         if (fdx == idx) idx = -1;
   897         return *this;
   898       }
   899 
   900       /// \brief Conversion operator
   901       ///
   902       /// It converts the iterator to the current item.
   903       operator const Item&() const {
   904         return extendFind->items[idx].item;
   905       }
   906 
   907       /// \brief Equality operator
   908       ///
   909       /// Equality operator
   910       bool operator==(const ItemIt& i) {
   911         return i.idx == idx;
   912       }
   913 
   914       /// \brief Inequality operator
   915       ///
   916       /// Inequality operator
   917       bool operator!=(const ItemIt& i) {
   918         return i.idx != idx;
   919       }
   920 
   921     private:
   922       const ExtendFindEnum* extendFind;
   923       int idx, fdx;
   924     };
   925 
   926   };
   927 
   928   /// \ingroup auxdat
   929   ///
   930   /// \brief A \e Union-Find data structure implementation which
   931   /// is able to store a priority for each item and retrieve the minimum of
   932   /// each class.
   933   ///
   934   /// A \e Union-Find data structure implementation which is able to
   935   /// store a priority for each item and retrieve the minimum of each
   936   /// class. In addition, it supports the joining and splitting the
   937   /// components. If you don't need this feature then you makes
   938   /// better to use the \ref UnionFind class which is more efficient.
   939   ///
   940   /// The union-find data strcuture based on a (2, 16)-tree with a
   941   /// tournament minimum selection on the internal nodes. The insert
   942   /// operation takes O(1), the find, set, decrease and increase takes
   943   /// O(log(n)), where n is the number of nodes in the current
   944   /// component.  The complexity of join and split is O(log(n)*k),
   945   /// where n is the sum of the number of the nodes and k is the
   946   /// number of joined components or the number of the components
   947   /// after the split.
   948   ///
   949   /// \pre You need to add all the elements by the \ref insert()
   950   /// method.
   951   ///
   952   template <typename _Value, typename _ItemIntMap,
   953             typename _Comp = std::less<_Value> >
   954   class HeapUnionFind {
   955   public:
   956 
   957     typedef _Value Value;
   958     typedef typename _ItemIntMap::Key Item;
   959 
   960     typedef _ItemIntMap ItemIntMap;
   961 
   962     typedef _Comp Comp;
   963 
   964   private:
   965 
   966     static const int cmax = 16;
   967 
   968     ItemIntMap& index;
   969 
   970     struct ClassNode {
   971       int parent;
   972       int depth;
   973 
   974       int left, right;
   975       int next, prev;
   976     };
   977 
   978     int first_class;
   979     int first_free_class;
   980     std::vector<ClassNode> classes;
   981 
   982     int newClass() {
   983       if (first_free_class < 0) {
   984         int id = classes.size();
   985         classes.push_back(ClassNode());
   986         return id;
   987       } else {
   988         int id = first_free_class;
   989         first_free_class = classes[id].next;
   990         return id;
   991       }
   992     }
   993 
   994     void deleteClass(int id) {
   995       classes[id].next = first_free_class;
   996       first_free_class = id;
   997     }
   998 
   999     struct ItemNode {
  1000       int parent;
  1001       Item item;
  1002       Value prio;
  1003       int next, prev;
  1004       int left, right;
  1005       int size;
  1006     };
  1007 
  1008     int first_free_node;
  1009     std::vector<ItemNode> nodes;
  1010 
  1011     int newNode() {
  1012       if (first_free_node < 0) {
  1013         int id = nodes.size();
  1014         nodes.push_back(ItemNode());
  1015         return id;
  1016       } else {
  1017         int id = first_free_node;
  1018         first_free_node = nodes[id].next;
  1019         return id;
  1020       }
  1021     }
  1022 
  1023     void deleteNode(int id) {
  1024       nodes[id].next = first_free_node;
  1025       first_free_node = id;
  1026     }
  1027 
  1028     Comp comp;
  1029 
  1030     int findClass(int id) const {
  1031       int kd = id;
  1032       while (kd >= 0) {
  1033         kd = nodes[kd].parent;
  1034       }
  1035       return ~kd;
  1036     }
  1037 
  1038     int leftNode(int id) const {
  1039       int kd = ~(classes[id].parent);
  1040       for (int i = 0; i < classes[id].depth; ++i) {
  1041         kd = nodes[kd].left;
  1042       }
  1043       return kd;
  1044     }
  1045 
  1046     int nextNode(int id) const {
  1047       int depth = 0;
  1048       while (id >= 0 && nodes[id].next == -1) {
  1049         id = nodes[id].parent;
  1050         ++depth;
  1051       }
  1052       if (id < 0) {
  1053         return -1;
  1054       }
  1055       id = nodes[id].next;
  1056       while (depth--) {
  1057         id = nodes[id].left;
  1058       }
  1059       return id;
  1060     }
  1061 
  1062 
  1063     void setPrio(int id) {
  1064       int jd = nodes[id].left;
  1065       nodes[id].prio = nodes[jd].prio;
  1066       nodes[id].item = nodes[jd].item;
  1067       jd = nodes[jd].next;
  1068       while (jd != -1) {
  1069         if (comp(nodes[jd].prio, nodes[id].prio)) {
  1070           nodes[id].prio = nodes[jd].prio;
  1071           nodes[id].item = nodes[jd].item;
  1072         }
  1073         jd = nodes[jd].next;
  1074       }
  1075     }
  1076 
  1077     void push(int id, int jd) {
  1078       nodes[id].size = 1;
  1079       nodes[id].left = nodes[id].right = jd;
  1080       nodes[jd].next = nodes[jd].prev = -1;
  1081       nodes[jd].parent = id;
  1082     }
  1083 
  1084     void pushAfter(int id, int jd) {
  1085       int kd = nodes[id].parent;
  1086       if (nodes[id].next != -1) {
  1087         nodes[nodes[id].next].prev = jd;
  1088         if (kd >= 0) {
  1089           nodes[kd].size += 1;
  1090         }
  1091       } else {
  1092         if (kd >= 0) {
  1093           nodes[kd].right = jd;
  1094           nodes[kd].size += 1;
  1095         }
  1096       }
  1097       nodes[jd].next = nodes[id].next;
  1098       nodes[jd].prev = id;
  1099       nodes[id].next = jd;
  1100       nodes[jd].parent = kd;
  1101     }
  1102 
  1103     void pushRight(int id, int jd) {
  1104       nodes[id].size += 1;
  1105       nodes[jd].prev = nodes[id].right;
  1106       nodes[jd].next = -1;
  1107       nodes[nodes[id].right].next = jd;
  1108       nodes[id].right = jd;
  1109       nodes[jd].parent = id;
  1110     }
  1111 
  1112     void popRight(int id) {
  1113       nodes[id].size -= 1;
  1114       int jd = nodes[id].right;
  1115       nodes[nodes[jd].prev].next = -1;
  1116       nodes[id].right = nodes[jd].prev;
  1117     }
  1118 
  1119     void splice(int id, int jd) {
  1120       nodes[id].size += nodes[jd].size;
  1121       nodes[nodes[id].right].next = nodes[jd].left;
  1122       nodes[nodes[jd].left].prev = nodes[id].right;
  1123       int kd = nodes[jd].left;
  1124       while (kd != -1) {
  1125         nodes[kd].parent = id;
  1126         kd = nodes[kd].next;
  1127       }
  1128       nodes[id].right = nodes[jd].right;
  1129     }
  1130 
  1131     void split(int id, int jd) {
  1132       int kd = nodes[id].parent;
  1133       nodes[kd].right = nodes[id].prev;
  1134       nodes[nodes[id].prev].next = -1;
  1135 
  1136       nodes[jd].left = id;
  1137       nodes[id].prev = -1;
  1138       int num = 0;
  1139       while (id != -1) {
  1140         nodes[id].parent = jd;
  1141         nodes[jd].right = id;
  1142         id = nodes[id].next;
  1143         ++num;
  1144       }
  1145       nodes[kd].size -= num;
  1146       nodes[jd].size = num;
  1147     }
  1148 
  1149     void pushLeft(int id, int jd) {
  1150       nodes[id].size += 1;
  1151       nodes[jd].next = nodes[id].left;
  1152       nodes[jd].prev = -1;
  1153       nodes[nodes[id].left].prev = jd;
  1154       nodes[id].left = jd;
  1155       nodes[jd].parent = id;
  1156     }
  1157 
  1158     void popLeft(int id) {
  1159       nodes[id].size -= 1;
  1160       int jd = nodes[id].left;
  1161       nodes[nodes[jd].next].prev = -1;
  1162       nodes[id].left = nodes[jd].next;
  1163     }
  1164 
  1165     void repairLeft(int id) {
  1166       int jd = ~(classes[id].parent);
  1167       while (nodes[jd].left != -1) {
  1168         int kd = nodes[jd].left;
  1169         if (nodes[jd].size == 1) {
  1170           if (nodes[jd].parent < 0) {
  1171             classes[id].parent = ~kd;
  1172             classes[id].depth -= 1;
  1173             nodes[kd].parent = ~id;
  1174             deleteNode(jd);
  1175             jd = kd;
  1176           } else {
  1177             int pd = nodes[jd].parent;
  1178             if (nodes[nodes[jd].next].size < cmax) {
  1179               pushLeft(nodes[jd].next, nodes[jd].left);
  1180               if (less(nodes[jd].left, nodes[jd].next)) {
  1181                 nodes[nodes[jd].next].prio = nodes[nodes[jd].left].prio;
  1182                 nodes[nodes[jd].next].item = nodes[nodes[jd].left].item;
  1183               }
  1184               popLeft(pd);
  1185               deleteNode(jd);
  1186               jd = pd;
  1187             } else {
  1188               int ld = nodes[nodes[jd].next].left;
  1189               popLeft(nodes[jd].next);
  1190               pushRight(jd, ld);
  1191               if (less(ld, nodes[jd].left)) {
  1192                 nodes[jd].item = nodes[ld].item;
  1193                 nodes[jd].prio = nodes[jd].prio;
  1194               }
  1195               if (nodes[nodes[jd].next].item == nodes[ld].item) {
  1196                 setPrio(nodes[jd].next);
  1197               }
  1198               jd = nodes[jd].left;
  1199             }
  1200           }
  1201         } else {
  1202           jd = nodes[jd].left;
  1203         }
  1204       }
  1205     }
  1206 
  1207     void repairRight(int id) {
  1208       int jd = ~(classes[id].parent);
  1209       while (nodes[jd].right != -1) {
  1210         int kd = nodes[jd].right;
  1211         if (nodes[jd].size == 1) {
  1212           if (nodes[jd].parent < 0) {
  1213             classes[id].parent = ~kd;
  1214             classes[id].depth -= 1;
  1215             nodes[kd].parent = ~id;
  1216             deleteNode(jd);
  1217             jd = kd;
  1218           } else {
  1219             int pd = nodes[jd].parent;
  1220             if (nodes[nodes[jd].prev].size < cmax) {
  1221               pushRight(nodes[jd].prev, nodes[jd].right);
  1222               if (less(nodes[jd].right, nodes[jd].prev)) {
  1223                 nodes[nodes[jd].prev].prio = nodes[nodes[jd].right].prio;
  1224                 nodes[nodes[jd].prev].item = nodes[nodes[jd].right].item;
  1225               }
  1226               popRight(pd);
  1227               deleteNode(jd);
  1228               jd = pd;
  1229             } else {
  1230               int ld = nodes[nodes[jd].prev].right;
  1231               popRight(nodes[jd].prev);
  1232               pushLeft(jd, ld);
  1233               if (less(ld, nodes[jd].right)) {
  1234                 nodes[jd].item = nodes[ld].item;
  1235                 nodes[jd].prio = nodes[jd].prio;
  1236               }
  1237               if (nodes[nodes[jd].prev].item == nodes[ld].item) {
  1238                 setPrio(nodes[jd].prev);
  1239               }
  1240               jd = nodes[jd].right;
  1241             }
  1242           }
  1243         } else {
  1244           jd = nodes[jd].right;
  1245         }
  1246       }
  1247     }
  1248 
  1249 
  1250     bool less(int id, int jd) const {
  1251       return comp(nodes[id].prio, nodes[jd].prio);
  1252     }
  1253 
  1254     bool equal(int id, int jd) const {
  1255       return !less(id, jd) && !less(jd, id);
  1256     }
  1257 
  1258 
  1259   public:
  1260 
  1261     /// \brief Returns true when the given class is alive.
  1262     ///
  1263     /// Returns true when the given class is alive, ie. the class is
  1264     /// not nested into other class.
  1265     bool alive(int cls) const {
  1266       return classes[cls].parent < 0;
  1267     }
  1268 
  1269     /// \brief Returns true when the given class is trivial.
  1270     ///
  1271     /// Returns true when the given class is trivial, ie. the class
  1272     /// contains just one item directly.
  1273     bool trivial(int cls) const {
  1274       return classes[cls].left == -1;
  1275     }
  1276 
  1277     /// \brief Constructs the union-find.
  1278     ///
  1279     /// Constructs the union-find.
  1280     /// \brief _index The index map of the union-find. The data
  1281     /// structure uses internally for store references.
  1282     HeapUnionFind(ItemIntMap& _index)
  1283       : index(_index), first_class(-1),
  1284         first_free_class(-1), first_free_node(-1) {}
  1285 
  1286     /// \brief Insert a new node into a new component.
  1287     ///
  1288     /// Insert a new node into a new component.
  1289     /// \param item The item of the new node.
  1290     /// \param prio The priority of the new node.
  1291     /// \return The class id of the one-item-heap.
  1292     int insert(const Item& item, const Value& prio) {
  1293       int id = newNode();
  1294       nodes[id].item = item;
  1295       nodes[id].prio = prio;
  1296       nodes[id].size = 0;
  1297 
  1298       nodes[id].prev = -1;
  1299       nodes[id].next = -1;
  1300 
  1301       nodes[id].left = -1;
  1302       nodes[id].right = -1;
  1303 
  1304       nodes[id].item = item;
  1305       index[item] = id;
  1306 
  1307       int class_id = newClass();
  1308       classes[class_id].parent = ~id;
  1309       classes[class_id].depth = 0;
  1310 
  1311       classes[class_id].left = -1;
  1312       classes[class_id].right = -1;
  1313 
  1314       if (first_class != -1) {
  1315         classes[first_class].prev = class_id;
  1316       }
  1317       classes[class_id].next = first_class;
  1318       classes[class_id].prev = -1;
  1319       first_class = class_id;
  1320 
  1321       nodes[id].parent = ~class_id;
  1322 
  1323       return class_id;
  1324     }
  1325 
  1326     /// \brief The class of the item.
  1327     ///
  1328     /// \return The alive class id of the item, which is not nested into
  1329     /// other classes.
  1330     ///
  1331     /// The time complexity is O(log(n)).
  1332     int find(const Item& item) const {
  1333       return findClass(index[item]);
  1334     }
  1335 
  1336     /// \brief Joins the classes.
  1337     ///
  1338     /// The current function joins the given classes. The parameter is
  1339     /// an STL range which should be contains valid class ids. The
  1340     /// time complexity is O(log(n)*k) where n is the overall number
  1341     /// of the joined nodes and k is the number of classes.
  1342     /// \return The class of the joined classes.
  1343     /// \pre The range should contain at least two class ids.
  1344     template <typename Iterator>
  1345     int join(Iterator begin, Iterator end) {
  1346       std::vector<int> cs;
  1347       for (Iterator it = begin; it != end; ++it) {
  1348         cs.push_back(*it);
  1349       }
  1350 
  1351       int class_id = newClass();
  1352       { // creation union-find
  1353 
  1354         if (first_class != -1) {
  1355           classes[first_class].prev = class_id;
  1356         }
  1357         classes[class_id].next = first_class;
  1358         classes[class_id].prev = -1;
  1359         first_class = class_id;
  1360 
  1361         classes[class_id].depth = classes[cs[0]].depth;
  1362         classes[class_id].parent = classes[cs[0]].parent;
  1363         nodes[~(classes[class_id].parent)].parent = ~class_id;
  1364 
  1365         int l = cs[0];
  1366 
  1367         classes[class_id].left = l;
  1368         classes[class_id].right = l;
  1369 
  1370         if (classes[l].next != -1) {
  1371           classes[classes[l].next].prev = classes[l].prev;
  1372         }
  1373         classes[classes[l].prev].next = classes[l].next;
  1374 
  1375         classes[l].prev = -1;
  1376         classes[l].next = -1;
  1377 
  1378         classes[l].depth = leftNode(l);
  1379         classes[l].parent = class_id;
  1380 
  1381       }
  1382 
  1383       { // merging of heap
  1384         int l = class_id;
  1385         for (int ci = 1; ci < int(cs.size()); ++ci) {
  1386           int r = cs[ci];
  1387           int rln = leftNode(r);
  1388           if (classes[l].depth > classes[r].depth) {
  1389             int id = ~(classes[l].parent);
  1390             for (int i = classes[r].depth + 1; i < classes[l].depth; ++i) {
  1391               id = nodes[id].right;
  1392             }
  1393             while (id >= 0 && nodes[id].size == cmax) {
  1394               int new_id = newNode();
  1395               int right_id = nodes[id].right;
  1396 
  1397               popRight(id);
  1398               if (nodes[id].item == nodes[right_id].item) {
  1399                 setPrio(id);
  1400               }
  1401               push(new_id, right_id);
  1402               pushRight(new_id, ~(classes[r].parent));
  1403               setPrio(new_id);
  1404 
  1405               id = nodes[id].parent;
  1406               classes[r].parent = ~new_id;
  1407             }
  1408             if (id < 0) {
  1409               int new_parent = newNode();
  1410               nodes[new_parent].next = -1;
  1411               nodes[new_parent].prev = -1;
  1412               nodes[new_parent].parent = ~l;
  1413 
  1414               push(new_parent, ~(classes[l].parent));
  1415               pushRight(new_parent, ~(classes[r].parent));
  1416               setPrio(new_parent);
  1417 
  1418               classes[l].parent = ~new_parent;
  1419               classes[l].depth += 1;
  1420             } else {
  1421               pushRight(id, ~(classes[r].parent));
  1422               while (id >= 0 && less(~(classes[r].parent), id)) {
  1423                 nodes[id].prio = nodes[~(classes[r].parent)].prio;
  1424                 nodes[id].item = nodes[~(classes[r].parent)].item;
  1425                 id = nodes[id].parent;
  1426               }
  1427             }
  1428           } else if (classes[r].depth > classes[l].depth) {
  1429             int id = ~(classes[r].parent);
  1430             for (int i = classes[l].depth + 1; i < classes[r].depth; ++i) {
  1431               id = nodes[id].left;
  1432             }
  1433             while (id >= 0 && nodes[id].size == cmax) {
  1434               int new_id = newNode();
  1435               int left_id = nodes[id].left;
  1436 
  1437               popLeft(id);
  1438               if (nodes[id].prio == nodes[left_id].prio) {
  1439                 setPrio(id);
  1440               }
  1441               push(new_id, left_id);
  1442               pushLeft(new_id, ~(classes[l].parent));
  1443               setPrio(new_id);
  1444 
  1445               id = nodes[id].parent;
  1446               classes[l].parent = ~new_id;
  1447 
  1448             }
  1449             if (id < 0) {
  1450               int new_parent = newNode();
  1451               nodes[new_parent].next = -1;
  1452               nodes[new_parent].prev = -1;
  1453               nodes[new_parent].parent = ~l;
  1454 
  1455               push(new_parent, ~(classes[r].parent));
  1456               pushLeft(new_parent, ~(classes[l].parent));
  1457               setPrio(new_parent);
  1458 
  1459               classes[r].parent = ~new_parent;
  1460               classes[r].depth += 1;
  1461             } else {
  1462               pushLeft(id, ~(classes[l].parent));
  1463               while (id >= 0 && less(~(classes[l].parent), id)) {
  1464                 nodes[id].prio = nodes[~(classes[l].parent)].prio;
  1465                 nodes[id].item = nodes[~(classes[l].parent)].item;
  1466                 id = nodes[id].parent;
  1467               }
  1468             }
  1469             nodes[~(classes[r].parent)].parent = ~l;
  1470             classes[l].parent = classes[r].parent;
  1471             classes[l].depth = classes[r].depth;
  1472           } else {
  1473             if (classes[l].depth != 0 &&
  1474                 nodes[~(classes[l].parent)].size +
  1475                 nodes[~(classes[r].parent)].size <= cmax) {
  1476               splice(~(classes[l].parent), ~(classes[r].parent));
  1477               deleteNode(~(classes[r].parent));
  1478               if (less(~(classes[r].parent), ~(classes[l].parent))) {
  1479                 nodes[~(classes[l].parent)].prio =
  1480                   nodes[~(classes[r].parent)].prio;
  1481                 nodes[~(classes[l].parent)].item =
  1482                   nodes[~(classes[r].parent)].item;
  1483               }
  1484             } else {
  1485               int new_parent = newNode();
  1486               nodes[new_parent].next = nodes[new_parent].prev = -1;
  1487               push(new_parent, ~(classes[l].parent));
  1488               pushRight(new_parent, ~(classes[r].parent));
  1489               setPrio(new_parent);
  1490 
  1491               classes[l].parent = ~new_parent;
  1492               classes[l].depth += 1;
  1493               nodes[new_parent].parent = ~l;
  1494             }
  1495           }
  1496           if (classes[r].next != -1) {
  1497             classes[classes[r].next].prev = classes[r].prev;
  1498           }
  1499           classes[classes[r].prev].next = classes[r].next;
  1500 
  1501           classes[r].prev = classes[l].right;
  1502           classes[classes[l].right].next = r;
  1503           classes[l].right = r;
  1504           classes[r].parent = l;
  1505 
  1506           classes[r].next = -1;
  1507           classes[r].depth = rln;
  1508         }
  1509       }
  1510       return class_id;
  1511     }
  1512 
  1513     /// \brief Split the class to subclasses.
  1514     ///
  1515     /// The current function splits the given class. The join, which
  1516     /// made the current class, stored a reference to the
  1517     /// subclasses. The \c splitClass() member restores the classes
  1518     /// and creates the heaps. The parameter is an STL output iterator
  1519     /// which will be filled with the subclass ids. The time
  1520     /// complexity is O(log(n)*k) where n is the overall number of
  1521     /// nodes in the splitted classes and k is the number of the
  1522     /// classes.
  1523     template <typename Iterator>
  1524     void split(int cls, Iterator out) {
  1525       std::vector<int> cs;
  1526       { // splitting union-find
  1527         int id = cls;
  1528         int l = classes[id].left;
  1529 
  1530         classes[l].parent = classes[id].parent;
  1531         classes[l].depth = classes[id].depth;
  1532 
  1533         nodes[~(classes[l].parent)].parent = ~l;
  1534 
  1535         *out++ = l;
  1536 
  1537         while (l != -1) {
  1538           cs.push_back(l);
  1539           l = classes[l].next;
  1540         }
  1541 
  1542         classes[classes[id].right].next = first_class;
  1543         classes[first_class].prev = classes[id].right;
  1544         first_class = classes[id].left;
  1545 
  1546         if (classes[id].next != -1) {
  1547           classes[classes[id].next].prev = classes[id].prev;
  1548         }
  1549         classes[classes[id].prev].next = classes[id].next;
  1550 
  1551         deleteClass(id);
  1552       }
  1553 
  1554       {
  1555         for (int i = 1; i < int(cs.size()); ++i) {
  1556           int l = classes[cs[i]].depth;
  1557           while (nodes[nodes[l].parent].left == l) {
  1558             l = nodes[l].parent;
  1559           }
  1560           int r = l;
  1561           while (nodes[l].parent >= 0) {
  1562             l = nodes[l].parent;
  1563             int new_node = newNode();
  1564 
  1565             nodes[new_node].prev = -1;
  1566             nodes[new_node].next = -1;
  1567 
  1568             split(r, new_node);
  1569             pushAfter(l, new_node);
  1570             setPrio(l);
  1571             setPrio(new_node);
  1572             r = new_node;
  1573           }
  1574           classes[cs[i]].parent = ~r;
  1575           classes[cs[i]].depth = classes[~(nodes[l].parent)].depth;
  1576           nodes[r].parent = ~cs[i];
  1577 
  1578           nodes[l].next = -1;
  1579           nodes[r].prev = -1;
  1580 
  1581           repairRight(~(nodes[l].parent));
  1582           repairLeft(cs[i]);
  1583 
  1584           *out++ = cs[i];
  1585         }
  1586       }
  1587     }
  1588 
  1589     /// \brief Gives back the priority of the current item.
  1590     ///
  1591     /// \return Gives back the priority of the current item.
  1592     const Value& operator[](const Item& item) const {
  1593       return nodes[index[item]].prio;
  1594     }
  1595 
  1596     /// \brief Sets the priority of the current item.
  1597     ///
  1598     /// Sets the priority of the current item.
  1599     void set(const Item& item, const Value& prio) {
  1600       if (comp(prio, nodes[index[item]].prio)) {
  1601         decrease(item, prio);
  1602       } else if (!comp(prio, nodes[index[item]].prio)) {
  1603         increase(item, prio);
  1604       }
  1605     }
  1606 
  1607     /// \brief Increase the priority of the current item.
  1608     ///
  1609     /// Increase the priority of the current item.
  1610     void increase(const Item& item, const Value& prio) {
  1611       int id = index[item];
  1612       int kd = nodes[id].parent;
  1613       nodes[id].prio = prio;
  1614       while (kd >= 0 && nodes[kd].item == item) {
  1615         setPrio(kd);
  1616         kd = nodes[kd].parent;
  1617       }
  1618     }
  1619 
  1620     /// \brief Increase the priority of the current item.
  1621     ///
  1622     /// Increase the priority of the current item.
  1623     void decrease(const Item& item, const Value& prio) {
  1624       int id = index[item];
  1625       int kd = nodes[id].parent;
  1626       nodes[id].prio = prio;
  1627       while (kd >= 0 && less(id, kd)) {
  1628         nodes[kd].prio = prio;
  1629         nodes[kd].item = item;
  1630         kd = nodes[kd].parent;
  1631       }
  1632     }
  1633 
  1634     /// \brief Gives back the minimum priority of the class.
  1635     ///
  1636     /// \return Gives back the minimum priority of the class.
  1637     const Value& classPrio(int cls) const {
  1638       return nodes[~(classes[cls].parent)].prio;
  1639     }
  1640 
  1641     /// \brief Gives back the minimum priority item of the class.
  1642     ///
  1643     /// \return Gives back the minimum priority item of the class.
  1644     const Item& classTop(int cls) const {
  1645       return nodes[~(classes[cls].parent)].item;
  1646     }
  1647 
  1648     /// \brief Gives back a representant item of the class.
  1649     ///
  1650     /// The representant is indpendent from the priorities of the
  1651     /// items.
  1652     /// \return Gives back a representant item of the class.
  1653     const Item& classRep(int id) const {
  1654       int parent = classes[id].parent;
  1655       return nodes[parent >= 0 ? classes[id].depth : leftNode(id)].item;
  1656     }
  1657 
  1658     /// \brief Lemon style iterator for the items of a class.
  1659     ///
  1660     /// ClassIt is a lemon style iterator for the components. It iterates
  1661     /// on the items of a class. By example if you want to iterate on
  1662     /// each items of each classes then you may write the next code.
  1663     ///\code
  1664     /// for (ClassIt cit(huf); cit != INVALID; ++cit) {
  1665     ///   std::cout << "Class: ";
  1666     ///   for (ItemIt iit(huf, cit); iit != INVALID; ++iit) {
  1667     ///     std::cout << toString(iit) << ' ' << std::endl;
  1668     ///   }
  1669     ///   std::cout << std::endl;
  1670     /// }
  1671     ///\endcode
  1672     class ItemIt {
  1673     private:
  1674 
  1675       const HeapUnionFind* _huf;
  1676       int _id, _lid;
  1677 
  1678     public:
  1679 
  1680       /// \brief Default constructor
  1681       ///
  1682       /// Default constructor
  1683       ItemIt() {}
  1684 
  1685       ItemIt(const HeapUnionFind& huf, int cls) : _huf(&huf) {
  1686         int id = cls;
  1687         int parent = _huf->classes[id].parent;
  1688         if (parent >= 0) {
  1689           _id = _huf->classes[id].depth;
  1690           if (_huf->classes[id].next != -1) {
  1691             _lid = _huf->classes[_huf->classes[id].next].depth;
  1692           } else {
  1693             _lid = -1;
  1694           }
  1695         } else {
  1696           _id = _huf->leftNode(id);
  1697           _lid = -1;
  1698         }
  1699       }
  1700 
  1701       /// \brief Increment operator
  1702       ///
  1703       /// It steps to the next item in the class.
  1704       ItemIt& operator++() {
  1705         _id = _huf->nextNode(_id);
  1706         return *this;
  1707       }
  1708 
  1709       /// \brief Conversion operator
  1710       ///
  1711       /// It converts the iterator to the current item.
  1712       operator const Item&() const {
  1713         return _huf->nodes[_id].item;
  1714       }
  1715 
  1716       /// \brief Equality operator
  1717       ///
  1718       /// Equality operator
  1719       bool operator==(const ItemIt& i) {
  1720         return i._id == _id;
  1721       }
  1722 
  1723       /// \brief Inequality operator
  1724       ///
  1725       /// Inequality operator
  1726       bool operator!=(const ItemIt& i) {
  1727         return i._id != _id;
  1728       }
  1729 
  1730       /// \brief Equality operator
  1731       ///
  1732       /// Equality operator
  1733       bool operator==(Invalid) {
  1734         return _id == _lid;
  1735       }
  1736 
  1737       /// \brief Inequality operator
  1738       ///
  1739       /// Inequality operator
  1740       bool operator!=(Invalid) {
  1741         return _id != _lid;
  1742       }
  1743 
  1744     };
  1745 
  1746     /// \brief Class iterator
  1747     ///
  1748     /// The iterator stores
  1749     class ClassIt {
  1750     private:
  1751 
  1752       const HeapUnionFind* _huf;
  1753       int _id;
  1754 
  1755     public:
  1756 
  1757       ClassIt(const HeapUnionFind& huf)
  1758         : _huf(&huf), _id(huf.first_class) {}
  1759 
  1760       ClassIt(const HeapUnionFind& huf, int cls)
  1761         : _huf(&huf), _id(huf.classes[cls].left) {}
  1762 
  1763       ClassIt(Invalid) : _huf(0), _id(-1) {}
  1764 
  1765       const ClassIt& operator++() {
  1766         _id = _huf->classes[_id].next;
  1767         return *this;
  1768       }
  1769 
  1770       /// \brief Equality operator
  1771       ///
  1772       /// Equality operator
  1773       bool operator==(const ClassIt& i) {
  1774         return i._id == _id;
  1775       }
  1776 
  1777       /// \brief Inequality operator
  1778       ///
  1779       /// Inequality operator
  1780       bool operator!=(const ClassIt& i) {
  1781         return i._id != _id;
  1782       }
  1783 
  1784       operator int() const {
  1785         return _id;
  1786       }
  1787 
  1788     };
  1789 
  1790   };
  1791 
  1792   //! @}
  1793 
  1794 } //namespace lemon
  1795 
  1796 #endif //LEMON_UNION_FIND_H