COIN-OR::LEMON - Graph Library

source: lemon-1.0/lemon/unionfind.h @ 234:ad6b8c47bd56

Last change on this file since 234:ad6b8c47bd56 was 220:a5d8c039f218, checked in by Balazs Dezso <deba@…>, 11 years ago

Reorganize header files (Ticket #97)

In addition on some places the DefaultMap?<G, K, V> is replaced with
ItemSetTraits?<G, K>::template Map<V>::Type, to decrease the dependencies
of different tools. It is obviously better solution.

File size: 48.3 KB
Line 
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/core.h>
34
35namespace 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
Note: See TracBrowser for help on using the repository browser.