diff -r bdc7dfc8c054 -r bb3392fe91f2 lemon/binom_heap.h
--- a/lemon/binom_heap.h	Thu Jul 09 02:39:47 2009 +0200
+++ b/lemon/binom_heap.h	Thu Jul 09 04:07:08 2009 +0200
@@ -1,8 +1,8 @@
-/* -*- C++ -*-
+/* -*- mode: C++; indent-tabs-mode: nil; -*-
  *
- * This file is a part of LEMON, a generic C++ optimization library
+ * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2008
+ * Copyright (C) 2003-2009
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
  *
@@ -20,193 +20,199 @@
 #define LEMON_BINOM_HEAP_H
 
 ///\file
-///\ingroup auxdat
+///\ingroup heaps
 ///\brief Binomial Heap implementation.
 
 #include <vector>
+#include <utility>
 #include <functional>
 #include <lemon/math.h>
 #include <lemon/counter.h>
 
 namespace lemon {
 
-  /// \ingroup auxdat
+  /// \ingroup heaps
   ///
-  ///\brief Binomial Heap.
+  ///\brief Binomial heap data structure.
   ///
-  ///This class implements the \e Binomial \e heap data structure. A \e heap
-  ///is a data structure for storing items with specified values called \e
-  ///priorities in such a way that finding the item with minimum priority is
-  ///efficient. \c Compare specifies the ordering of the priorities. In a heap
-  ///one can change the priority of an item, add or erase an item, etc.
+  /// This class implements the \e binomial \e heap data structure.
+  /// It fully conforms to the \ref concepts::Heap "heap concept".
   ///
-  ///The methods \ref increase and \ref erase are not efficient in a Binomial
-  ///heap. In case of many calls to these operations, it is better to use a
-  ///\ref BinHeap "binary heap".
+  /// The methods \ref increase() and \ref erase() are not efficient
+  /// in a binomial heap. In case of many calls of these operations,
+  /// it is better to use other heap structure, e.g. \ref BinHeap
+  /// "binary heap".
   ///
-  ///\param _Prio Type of the priority of the items.
-  ///\param _ItemIntMap A read and writable Item int map, used internally
-  ///to handle the cross references.
-  ///\param _Compare A class for the ordering of the priorities. The
-  ///default is \c std::less<_Prio>.
-  ///
-  ///\sa BinHeap
-  ///\sa Dijkstra
-  ///\author Dorian Batha
-
+  /// \tparam PR Type of the priorities of the items.
+  /// \tparam IM A read-writable item map with \c int values, used
+  /// internally to handle the cross references.
+  /// \tparam CMP A functor class for comparing the priorities.
+  /// The default is \c std::less<PR>.
 #ifdef DOXYGEN
-  template <typename _Prio,
-            typename _ItemIntMap,
-            typename _Compare>
+  template <typename PR, typename IM, typename CMP>
 #else
-  template <typename _Prio,
-            typename _ItemIntMap,
-            typename _Compare = std::less<_Prio> >
+  template <typename PR, typename IM, typename CMP = std::less<PR> >
 #endif
   class BinomHeap {
   public:
-    typedef _ItemIntMap ItemIntMap;
-    typedef _Prio Prio;
+    /// Type of the item-int map.
+    typedef IM ItemIntMap;
+    /// Type of the priorities.
+    typedef PR Prio;
+    /// Type of the items stored in the heap.
     typedef typename ItemIntMap::Key Item;
-    typedef std::pair<Item,Prio> Pair;
-    typedef _Compare Compare;
+    /// Functor type for comparing the priorities.
+    typedef CMP Compare;
+
+    /// \brief Type to represent the states of the items.
+    ///
+    /// Each item has a state associated to it. It can be "in heap",
+    /// "pre-heap" or "post-heap". The latter two are indifferent from the
+    /// heap's point of view, but may be useful to the user.
+    ///
+    /// The item-int map must be initialized in such way that it assigns
+    /// \c PRE_HEAP (<tt>-1</tt>) to any element to be put in the heap.
+    enum State {
+      IN_HEAP = 0,    ///< = 0.
+      PRE_HEAP = -1,  ///< = -1.
+      POST_HEAP = -2  ///< = -2.
+    };
 
   private:
     class store;
 
-    std::vector<store> container;
-    int minimum, head;
-    ItemIntMap &iimap;
-    Compare comp;
-    int num_items;
+    std::vector<store> _data;
+    int _min, _head;
+    ItemIntMap &_iim;
+    Compare _comp;
+    int _num_items;
 
   public:
-    ///Status of the nodes
-    enum State {
-      ///The node is in the heap
-      IN_HEAP = 0,
-      ///The node has never been in the heap
-      PRE_HEAP = -1,
-      ///The node was in the heap but it got out of it
-      POST_HEAP = -2
-    };
+    /// \brief Constructor.
+    ///
+    /// Constructor.
+    /// \param map A map that assigns \c int values to the items.
+    /// It is used internally to handle the cross references.
+    /// The assigned value must be \c PRE_HEAP (<tt>-1</tt>) for each item.
+    explicit BinomHeap(ItemIntMap &map)
+      : _min(0), _head(-1), _iim(map), _num_items(0) {}
 
-    /// \brief The constructor
+    /// \brief Constructor.
     ///
-    /// \c _iimap should be given to the constructor, since it is
-    ///   used internally to handle the cross references.
-    explicit BinomHeap(ItemIntMap &_iimap)
-      : minimum(0), head(-1), iimap(_iimap), num_items() {}
-
-    /// \brief The constructor
-    ///
-    /// \c _iimap should be given to the constructor, since it is used
-    /// internally to handle the cross references. \c _comp is an
-    /// object for ordering of the priorities.
-    BinomHeap(ItemIntMap &_iimap, const Compare &_comp)
-      : minimum(0), head(-1), iimap(_iimap), comp(_comp), num_items() {}
+    /// Constructor.
+    /// \param map A map that assigns \c int values to the items.
+    /// It is used internally to handle the cross references.
+    /// The assigned value must be \c PRE_HEAP (<tt>-1</tt>) for each item.
+    /// \param comp The function object used for comparing the priorities.
+    BinomHeap(ItemIntMap &map, const Compare &comp)
+      : _min(0), _head(-1), _iim(map), _comp(comp), _num_items(0) {}
 
     /// \brief The number of items stored in the heap.
     ///
-    /// Returns the number of items stored in the heap.
-    int size() const { return num_items; }
+    /// This function returns the number of items stored in the heap.
+    int size() const { return _num_items; }
 
-    /// \brief Checks if the heap stores no items.
+    /// \brief Check if the heap is empty.
     ///
-    ///   Returns \c true if and only if the heap stores no items.
-    bool empty() const { return num_items==0; }
+    /// This function returns \c true if the heap is empty.
+    bool empty() const { return _num_items==0; }
 
-    /// \brief Make empty this heap.
+    /// \brief Make the heap empty.
     ///
-    /// Make empty this heap. It does not change the cross reference
-    /// map.  If you want to reuse a heap what is not surely empty you
-    /// should first clear the heap and after that you should set the
-    /// cross reference map for each item to \c PRE_HEAP.
+    /// This functon makes the heap empty.
+    /// It does not change the cross reference map. If you want to reuse
+    /// a heap that is not surely empty, you should first clear it and
+    /// then you should set the cross reference map to \c PRE_HEAP
+    /// for each item.
     void clear() {
-      container.clear(); minimum=0; num_items=0; head=-1;
+      _data.clear(); _min=0; _num_items=0; _head=-1;
     }
 
-    /// \brief \c item gets to the heap with priority \c value independently
-    /// if \c item was already there.
+    /// \brief Set the priority of an item or insert it, if it is
+    /// not stored in the heap.
     ///
-    /// This method calls \ref push(\c item, \c value) if \c item is not
-    /// stored in the heap and it calls \ref decrease(\c item, \c value) or
-    /// \ref increase(\c item, \c value) otherwise.
+    /// This method sets the priority of the given item if it is
+    /// already stored in the heap. Otherwise it inserts the given
+    /// item into the heap with the given priority.
+    /// \param item The item.
+    /// \param value The priority.
     void set (const Item& item, const Prio& value) {
-      int i=iimap[item];
-      if ( i >= 0 && container[i].in ) {
-        if ( comp(value, container[i].prio) ) decrease(item, value);
-        if ( comp(container[i].prio, value) ) increase(item, value);
+      int i=_iim[item];
+      if ( i >= 0 && _data[i].in ) {
+        if ( _comp(value, _data[i].prio) ) decrease(item, value);
+        if ( _comp(_data[i].prio, value) ) increase(item, value);
       } else push(item, value);
     }
 
-    /// \brief Adds \c item to the heap with priority \c value.
+    /// \brief Insert an item into the heap with the given priority.
     ///
-    /// Adds \c item to the heap with priority \c value.
-    /// \pre \c item must not be stored in the heap.
+    /// This function inserts the given item into the heap with the
+    /// given priority.
+    /// \param item The item to insert.
+    /// \param value The priority of the item.
+    /// \pre \e item must not be stored in the heap.
     void push (const Item& item, const Prio& value) {
-      int i=iimap[item];
+      int i=_iim[item];
       if ( i<0 ) {
-        int s=container.size();
-        iimap.set( item,s );
+        int s=_data.size();
+        _iim.set( item,s );
         store st;
         st.name=item;
-        container.push_back(st);
+        _data.push_back(st);
         i=s;
       }
       else {
-        container[i].parent=container[i].right_neighbor=container[i].child=-1;
-        container[i].degree=0;
-        container[i].in=true;
+        _data[i].parent=_data[i].right_neighbor=_data[i].child=-1;
+        _data[i].degree=0;
+        _data[i].in=true;
       }
-      container[i].prio=value;
+      _data[i].prio=value;
 
-      if( 0==num_items ) { head=i; minimum=i; }
+      if( 0==_num_items ) { _head=i; _min=i; }
       else { merge(i); }
 
-      minimum = find_min();
+      _min = findMin();
 
-      ++num_items;
+      ++_num_items;
     }
 
-    /// \brief Returns the item with minimum priority relative to \c Compare.
+    /// \brief Return the item having minimum priority.
     ///
-    /// This method returns the item with minimum priority relative to \c
-    /// Compare.
-    /// \pre The heap must be nonempty.
-    Item top() const { return container[minimum].name; }
+    /// This function returns the item having minimum priority.
+    /// \pre The heap must be non-empty.
+    Item top() const { return _data[_min].name; }
 
-    /// \brief Returns the minimum priority relative to \c Compare.
+    /// \brief The minimum priority.
     ///
-    /// It returns the minimum priority relative to \c Compare.
-    /// \pre The heap must be nonempty.
-    const Prio& prio() const { return container[minimum].prio; }
+    /// This function returns the minimum priority.
+    /// \pre The heap must be non-empty.
+    Prio prio() const { return _data[_min].prio; }
 
-    /// \brief Returns the priority of \c item.
+    /// \brief The priority of the given item.
     ///
-    /// It returns the priority of \c item.
-    /// \pre \c item must be in the heap.
+    /// This function returns the priority of the given item.
+    /// \param item The item.
+    /// \pre \e item must be in the heap.
     const Prio& operator[](const Item& item) const {
-      return container[iimap[item]].prio;
+      return _data[_iim[item]].prio;
     }
 
-    /// \brief Deletes the item with minimum priority relative to \c Compare.
+    /// \brief Remove the item having minimum priority.
     ///
-    /// This method deletes the item with minimum priority relative to \c
-    /// Compare from the heap.
+    /// This function removes the item having minimum priority.
     /// \pre The heap must be non-empty.
     void pop() {
-      container[minimum].in=false;
+      _data[_min].in=false;
 
       int head_child=-1;
-      if ( container[minimum].child!=-1 ) {
-        int child=container[minimum].child;
+      if ( _data[_min].child!=-1 ) {
+        int child=_data[_min].child;
         int neighb;
         int prev=-1;
         while( child!=-1 ) {
-          neighb=container[child].right_neighbor;
-          container[child].parent=-1;
-          container[child].right_neighbor=prev;
+          neighb=_data[child].right_neighbor;
+          _data[child].parent=-1;
+          _data[child].right_neighbor=prev;
           head_child=child;
           prev=child;
           child=neighb;
@@ -214,142 +220,144 @@
       }
 
       // The first case is that there are only one root.
-      if ( -1==container[head].right_neighbor ) {
-        head=head_child;
+      if ( -1==_data[_head].right_neighbor ) {
+        _head=head_child;
       }
       // The case where there are more roots.
       else {
-        if( head!=minimum )  { unlace(minimum); }
-        else { head=container[head].right_neighbor; }
+        if( _head!=_min )  { unlace(_min); }
+        else { _head=_data[_head].right_neighbor; }
 
         merge(head_child);
       }
-      minimum=find_min();
-      --num_items;
+      _min=findMin();
+      --_num_items;
     }
 
-    /// \brief Deletes \c item from the heap.
+    /// \brief Remove the given item from the heap.
     ///
-    /// This method deletes \c item from the heap, if \c item was already
-    /// stored in the heap. It is quite inefficient in Binomial heaps.
+    /// This function removes the given item from the heap if it is
+    /// already stored.
+    /// \param item The item to delete.
+    /// \pre \e item must be in the heap.
     void erase (const Item& item) {
-      int i=iimap[item];
-      if ( i >= 0 && container[i].in ) {
-        decrease( item, container[minimum].prio-1 );
+      int i=_iim[item];
+      if ( i >= 0 && _data[i].in ) {
+        decrease( item, _data[_min].prio-1 );
         pop();
       }
     }
 
-    /// \brief Decreases the priority of \c item to \c value.
+    /// \brief Decrease the priority of an item to the given value.
     ///
-    /// This method decreases the priority of \c item to \c value.
-    /// \pre \c item must be stored in the heap with priority at least \c
-    ///   value relative to \c Compare.
+    /// This function decreases the priority of an item to the given value.
+    /// \param item The item.
+    /// \param value The priority.
+    /// \pre \e item must be stored in the heap with priority at least \e value.
     void decrease (Item item, const Prio& value) {
-      int i=iimap[item];
+      int i=_iim[item];
 
-      if( comp( value,container[i].prio ) ) {
-        container[i].prio=value;
+      if( _comp( value,_data[i].prio ) ) {
+        _data[i].prio=value;
 
-        int p_loc=container[i].parent, loc=i;
+        int p_loc=_data[i].parent, loc=i;
         int parent, child, neighb;
 
-        while( -1!=p_loc && comp(container[loc].prio,container[p_loc].prio) ) {
+        while( -1!=p_loc && _comp(_data[loc].prio,_data[p_loc].prio) ) {
 
           // parent set for other loc_child
-          child=container[loc].child;
+          child=_data[loc].child;
           while( -1!=child ) {
-            container[child].parent=p_loc;
-            child=container[child].right_neighbor;
+            _data[child].parent=p_loc;
+            child=_data[child].right_neighbor;
           }
 
           // parent set for other p_loc_child
-          child=container[p_loc].child;
+          child=_data[p_loc].child;
           while( -1!=child ) {
-            container[child].parent=loc;
-            child=container[child].right_neighbor;
+            _data[child].parent=loc;
+            child=_data[child].right_neighbor;
           }
 
-          child=container[p_loc].child;
-          container[p_loc].child=container[loc].child;
+          child=_data[p_loc].child;
+          _data[p_loc].child=_data[loc].child;
           if( child==loc )
             child=p_loc;
-          container[loc].child=child;
+          _data[loc].child=child;
 
           // left_neighb set for p_loc
-          if( container[loc].child!=p_loc ) {
-            while( container[child].right_neighbor!=loc )
-              child=container[child].right_neighbor;
-            container[child].right_neighbor=p_loc;
+          if( _data[loc].child!=p_loc ) {
+            while( _data[child].right_neighbor!=loc )
+              child=_data[child].right_neighbor;
+            _data[child].right_neighbor=p_loc;
           }
 
           // left_neighb set for loc
-          parent=container[p_loc].parent;
-          if( -1!=parent ) child=container[parent].child;
-          else child=head;
+          parent=_data[p_loc].parent;
+          if( -1!=parent ) child=_data[parent].child;
+          else child=_head;
 
           if( child!=p_loc ) {
-            while( container[child].right_neighbor!=p_loc )
-              child=container[child].right_neighbor;
-            container[child].right_neighbor=loc;
+            while( _data[child].right_neighbor!=p_loc )
+              child=_data[child].right_neighbor;
+            _data[child].right_neighbor=loc;
           }
 
-          neighb=container[p_loc].right_neighbor;
-          container[p_loc].right_neighbor=container[loc].right_neighbor;
-          container[loc].right_neighbor=neighb;
+          neighb=_data[p_loc].right_neighbor;
+          _data[p_loc].right_neighbor=_data[loc].right_neighbor;
+          _data[loc].right_neighbor=neighb;
 
-          container[p_loc].parent=loc;
-          container[loc].parent=parent;
+          _data[p_loc].parent=loc;
+          _data[loc].parent=parent;
 
-          if( -1!=parent && container[parent].child==p_loc )
-            container[parent].child=loc;
+          if( -1!=parent && _data[parent].child==p_loc )
+            _data[parent].child=loc;
 
           /*if new parent will be the first root*/
-          if( head==p_loc )
-            head=loc;
+          if( _head==p_loc )
+            _head=loc;
 
-          p_loc=container[loc].parent;
+          p_loc=_data[loc].parent;
         }
       }
-      if( comp(value,container[minimum].prio) ) {
-        minimum=i;
+      if( _comp(value,_data[_min].prio) ) {
+        _min=i;
       }
     }
 
-    /// \brief Increases the priority of \c item to \c value.
+    /// \brief Increase the priority of an item to the given value.
     ///
-    /// This method sets the priority of \c item to \c value. Though
-    /// there is no precondition on the priority of \c item, this
-    /// method should be used only if it is indeed necessary to increase
-    /// (relative to \c Compare) the priority of \c item, because this
-    /// method is inefficient.
+    /// This function increases the priority of an item to the given value.
+    /// \param item The item.
+    /// \param value The priority.
+    /// \pre \e item must be stored in the heap with priority at most \e value.
     void increase (Item item, const Prio& value) {
       erase(item);
       push(item, value);
     }
 
-
-    /// \brief Returns if \c item is in, has already been in, or has never
-    /// been in the heap.
+    /// \brief Return the state of an item.
     ///
-    /// This method returns PRE_HEAP if \c item has never been in the
-    /// heap, IN_HEAP if it is in the heap at the moment, and POST_HEAP
-    /// otherwise. In the latter case it is possible that \c item will
-    /// get back to the heap again.
+    /// This method returns \c PRE_HEAP if the given item has never
+    /// been in the heap, \c IN_HEAP if it is in the heap at the moment,
+    /// and \c POST_HEAP otherwise.
+    /// In the latter case it is possible that the item will get back
+    /// to the heap again.
+    /// \param item The item.
     State state(const Item &item) const {
-      int i=iimap[item];
+      int i=_iim[item];
       if( i>=0 ) {
-        if ( container[i].in ) i=0;
+        if ( _data[i].in ) i=0;
         else i=-2;
       }
       return State(i);
     }
 
-    /// \brief Sets the state of the \c item in the heap.
+    /// \brief Set the state of an item in the heap.
     ///
-    /// Sets the state of the \c item in the heap. It can be used to
-    /// manually clear the heap when it is important to achive the
-    /// better time complexity.
+    /// This function sets the state of the given item in the heap.
+    /// It can be used to manually clear the heap when it is important
+    /// to achive better time complexity.
     /// \param i The item.
     /// \param st The state. It should not be \c IN_HEAP.
     void state(const Item& i, State st) {
@@ -359,7 +367,7 @@
         if (state(i) == IN_HEAP) {
           erase(i);
         }
-        iimap[i] = st;
+        _iim[i] = st;
         break;
       case IN_HEAP:
         break;
@@ -367,20 +375,20 @@
     }
 
   private:
-    int find_min() {
+    int findMin() {
       int min_loc=-1, min_val;
-      int x=head;
+      int x=_head;
       if( x!=-1 ) {
-        min_val=container[x].prio;
+        min_val=_data[x].prio;
         min_loc=x;
-        x=container[x].right_neighbor;
+        x=_data[x].right_neighbor;
 
         while( x!=-1 ) {
-          if( comp( container[x].prio,min_val ) ) {
-            min_val=container[x].prio;
+          if( _comp( _data[x].prio,min_val ) ) {
+            min_val=_data[x].prio;
             min_loc=x;
           }
-          x=container[x].right_neighbor;
+          x=_data[x].right_neighbor;
         }
       }
       return min_loc;
@@ -389,29 +397,29 @@
     void merge(int a) {
       interleave(a);
 
-      int x=head;
+      int x=_head;
       if( -1!=x ) {
-        int x_prev=-1, x_next=container[x].right_neighbor;
+        int x_prev=-1, x_next=_data[x].right_neighbor;
         while( -1!=x_next ) {
-          if( container[x].degree!=container[x_next].degree || ( -1!=container[x_next].right_neighbor && container[container[x_next].right_neighbor].degree==container[x].degree ) ) {
+          if( _data[x].degree!=_data[x_next].degree || ( -1!=_data[x_next].right_neighbor && _data[_data[x_next].right_neighbor].degree==_data[x].degree ) ) {
             x_prev=x;
             x=x_next;
           }
           else {
-            if( comp(container[x].prio,container[x_next].prio) ) {
-              container[x].right_neighbor=container[x_next].right_neighbor;
+            if( _comp(_data[x].prio,_data[x_next].prio) ) {
+              _data[x].right_neighbor=_data[x_next].right_neighbor;
               fuse(x_next,x);
             }
             else {
-              if( -1==x_prev ) { head=x_next; }
+              if( -1==x_prev ) { _head=x_next; }
               else {
-                container[x_prev].right_neighbor=x_next;
+                _data[x_prev].right_neighbor=x_next;
               }
               fuse(x,x_next);
               x=x_next;
             }
           }
-          x_next=container[x].right_neighbor;
+          x_next=_data[x].right_neighbor;
         }
       }
     }
@@ -419,68 +427,68 @@
     void interleave(int a) {
       int other=-1, head_other=-1;
 
-      while( -1!=a || -1!=head ) {
+      while( -1!=a || -1!=_head ) {
         if( -1==a ) {
           if( -1==head_other ) {
-            head_other=head;
+            head_other=_head;
           }
           else {
-            container[other].right_neighbor=head;
+            _data[other].right_neighbor=_head;
           }
-          head=-1;
+          _head=-1;
         }
-        else if( -1==head ) {
+        else if( -1==_head ) {
           if( -1==head_other ) {
             head_other=a;
           }
           else {
-            container[other].right_neighbor=a;
+            _data[other].right_neighbor=a;
           }
           a=-1;
         }
         else {
-          if( container[a].degree<container[head].degree ) {
+          if( _data[a].degree<_data[_head].degree ) {
             if( -1==head_other ) {
               head_other=a;
             }
             else {
-              container[other].right_neighbor=a;
+              _data[other].right_neighbor=a;
             }
             other=a;
-            a=container[a].right_neighbor;
+            a=_data[a].right_neighbor;
           }
           else {
             if( -1==head_other ) {
-              head_other=head;
+              head_other=_head;
             }
             else {
-              container[other].right_neighbor=head;
+              _data[other].right_neighbor=_head;
             }
-            other=head;
-            head=container[head].right_neighbor;
+            other=_head;
+            _head=_data[_head].right_neighbor;
           }
         }
       }
-      head=head_other;
+      _head=head_other;
     }
 
     // Lacing a under b
     void fuse(int a, int b) {
-      container[a].parent=b;
-      container[a].right_neighbor=container[b].child;
-      container[b].child=a;
+      _data[a].parent=b;
+      _data[a].right_neighbor=_data[b].child;
+      _data[b].child=a;
 
-      ++container[b].degree;
+      ++_data[b].degree;
     }
 
     // It is invoked only if a has siblings.
     void unlace(int a) {
-      int neighb=container[a].right_neighbor;
-      int other=head;
+      int neighb=_data[a].right_neighbor;
+      int other=_head;
 
-      while( container[other].right_neighbor!=a )
-        other=container[other].right_neighbor;
-      container[other].right_neighbor=neighb;
+      while( _data[other].right_neighbor!=a )
+        other=_data[other].right_neighbor;
+      _data[other].right_neighbor=neighb;
     }
 
   private: