LEMON/LEMON-main Changeset - r703:bb3392fe91f2

Repositories » LEMON » LEMON-main

Summary
Changelog
Files
Switch To
- loading...
Options
- Lightweight changelog
- Search
Pull Requests

Changeset - r703:bb3392fe91f2

« 702:bdc7df

704:7124b2 »

r703:bb3392fe91f2

Thu, 09 Jul 2009 04:07:08

[Not Reviewed]

0 comments (0 inline)

kpeter (Peter Kovacs)
kpeter@inf.elte.hu

Improve and unify the doc + names in the new heaps (#301)

0 4 0

default

4 files changed with 839 insertions and 820 deletions:

lemon/binom_heap.h

235

227

lemon/fourary_heap.h

175

174

lemon/kary_heap.h

185

184

lemon/pairing_heap.h

244

235

↑ Collapse diff ↑

lemon/binom_heap.h

Show inline comments

 		/* -*- 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).
+		 *
 		 * Permission to use, modify and distribute this software is granted
 		 * provided that this copyright notice appears in all copies. For
 		 * precise terms see the accompanying LICENSE file.
+		 *
 		 * This software is provided "AS IS" with no warranty of any kind,
 		 * express or implied, and with no claim as to its suitability for any
 		 * purpose.
+		 *
 		 */
 		#ifndef LEMON_BINOM_HEAP_H
 		#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;
+		        }
+		      }
 		      // 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) {
 		      switch (st) {
 		      case POST_HEAP:
 		      case PRE_HEAP:
 		        if (state(i) == IN_HEAP) {
 		          erase(i);
+		        }
-		        iimap[i] = st;
+		        _iim[i] = st;
 		        break;
 		      case IN_HEAP:
 		        break;
+		      }
+		    }
 		  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;
+		    }
 		    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;
+		        }
+		      }
+		    }
 		    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:
 		    class store {
 		      friend class BinomHeap;
 		      Item name;
 		      int parent;
 		      int right_neighbor;
 		      int child;
 		      int degree;
 		      bool in;
 		      Prio prio;
 		      store() : parent(-1), right_neighbor(-1), child(-1), degree(0), in(true) {}
 		    };
 		  };
 		} //namespace lemon
 		#endif //LEMON_BINOM_HEAP_H

lemon/fourary_heap.h

Show inline comments

 		/* -*- 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).
+		 *
 		 * Permission to use, modify and distribute this software is granted
 		 * provided that this copyright notice appears in all copies. For
 		 * precise terms see the accompanying LICENSE file.
+		 *
 		 * This software is provided "AS IS" with no warranty of any kind,
 		 * express or implied, and with no claim as to its suitability for any
 		 * purpose.
+		 *
 		 */
 		#ifndef LEMON_FOURARY_HEAP_H
 		#define LEMON_FOURARY_HEAP_H
-		///\ingroup auxdat
+		///\ingroup heaps
 		///\file
-		///\brief 4ary Heap implementation.
+		///\brief Fourary heap implementation.
 		#include <iostream>
 		#include <vector>
 		#include <utility>
 		#include <functional>
 		namespace lemon {
-		  ///\ingroup auxdat
+		  /// \ingroup heaps
 		  ///
-		  ///\brief A 4ary Heap implementation.
+		  ///\brief Fourary heap data structure.
 		  ///
 		  ///This class implements the \e 4ary \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 fourary \e heap data structure.
 		  /// It fully conforms to the \ref concepts::Heap "heap concept".
 		  ///
 		  ///\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>.
+		  /// The fourary heap is a specialization of the \ref KaryHeap "K-ary heap"
 		  /// for <tt>K=4</tt>. It is similar to the \ref BinHeap "binary heap",
 		  /// but its nodes have at most four children, instead of two.
 		  ///
 		  ///\sa FibHeap
 		  ///\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>.
 		  ///
 		  ///\sa BinHeap
 		  ///\sa KaryHeap
 		#ifdef DOXYGEN
 		  template <typename PR, typename IM, typename CMP>
 		#else
 		  template <typename PR, typename IM, typename CMP = std::less<PR> >
 		#endif
 		  class FouraryHeap {
 		  public:
 		    /// 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;
 		    /// Type of the item-priority pairs.
 		    typedef std::pair<Item,Prio> Pair;
 		    /// Functor type for comparing the priorities.
 		    typedef CMP Compare;
 		  template <typename _Prio, typename _ItemIntMap,
 		            typename _Compare = std::less<_Prio> >
 		  class FouraryHeap {
 		  public:
 		    ///\e
 		    typedef _ItemIntMap ItemIntMap;
 		    ///\e
 		    typedef _Prio Prio;
 		    ///\e
 		    typedef typename ItemIntMap::Key Item;
 		    ///\e
 		    typedef std::pair<Item,Prio> Pair;
 		    ///\e
 		    typedef _Compare Compare;
 		    /// \brief Type to represent the items states.
 		    /// \brief Type to represent the states of the items.
 		    ///
 		    /// Each Item element have a state associated to it. It may be "in heap",
 		    /// "pre heap" or "post heap". The latter two are indifferent from the
 		    /// 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 ItemIntMap \e should be initialized in such way that it maps
 		    /// PRE_HEAP (-1) to any element to be put in the heap...
 		    /// 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,
 		      PRE_HEAP = -1,
-		      POST_HEAP = -2
+		      IN_HEAP = 0,    ///< = 0.
 		      PRE_HEAP = -1,  ///< = -1.
 		      POST_HEAP = -2  ///< = -2.
 		    };
 		  private:
 		    std::vector<Pair> data;
 		    Compare comp;
-		    ItemIntMap &iim;
+		    std::vector<Pair> _data;
 		    Compare _comp;
 		    ItemIntMap &_iim;
 		  public:
-		    /// \brief The constructor.
+		    /// \brief Constructor.
 		    ///
 		    /// The constructor.
 		    /// \param _iim should be given to the constructor, since it is used
 		    /// internally to handle the cross references. The value of the map
 		    /// should be PRE_HEAP (-1) for each element.
-		    explicit FouraryHeap(ItemIntMap &_iim) : iim(_iim) {}
+		    /// 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 FouraryHeap(ItemIntMap &map) : _iim(map) {}
-		    /// \brief The constructor.
+		    /// \brief Constructor.
 		    ///
 		    /// The constructor.
 		    /// \param _iim should be given to the constructor, since it is used
 		    /// internally to handle the cross references. The value of the map
 		    /// should be PRE_HEAP (-1) for each element.
 		    /// 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.
 		    FouraryHeap(ItemIntMap &map, const Compare &comp)
 		      : _iim(map), _comp(comp) {}
 		    /// \brief The number of items stored in the heap.
 		    ///
 		    /// \param _comp The comparator function object.
 		    FouraryHeap(ItemIntMap &_iim, const Compare &_comp)
-		      : iim(_iim), comp(_comp) {}
+		    /// This function returns the number of items stored in the heap.
 		    int size() const { return _data.size(); }
-		    /// The number of items stored in the heap.
+		    /// \brief Check if the heap is empty.
 		    ///
 		    /// \brief Returns the number of items stored in the heap.
 		    int size() const { return data.size(); }
 		    /// This function returns \c true if the heap is empty.
 		    bool empty() const { return _data.empty(); }
-		    /// \brief Checks if the heap stores no items.
+		    /// \brief Make the heap empty.
 		    ///
 		    /// Returns \c true if and only if the heap stores no items.
 		    bool empty() const { return data.empty(); }
 		    /// \brief Make empty this heap.
 		    ///
 		    /// Make empty this heap. It does not change the cross reference map.
 		    /// If you want to reuse 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.
 		    void clear() { data.clear(); }
 		    /// 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() { _data.clear(); }
 		  private:
 		    static int parent(int i) { return (i-1)/4; }
 		    static int firstChild(int i) { return 4*i+1; }
 		    bool less(const Pair &p1, const Pair &p2) const {
-		      return comp(p1.second, p2.second);
+		      return _comp(p1.second, p2.second);
+		    }
-		    int find_min(const int child, const int length) {
+		    int findMin(const int child, const int length) {
 		      int min=child;
 		      if( child+3<length ) {
-		        if( less(data[child+3], data[min]) )
+		        if( less(_data[child+3], _data[min]) )
 		          min=child+3;
-		        if( less(data[child+2], data[min]) )
+		        if( less(_data[child+2], _data[min]) )
 		          min=child+2;
-		        if( less(data[child+1], data[min]) )
+		        if( less(_data[child+1], _data[min]) )
 		          min=child+1;
+		      }
 		      else if( child+2<length ) {
-		        if( less(data[child+2], data[min]) )
+		        if( less(_data[child+2], _data[min]) )
 		          min=child+2;
-		        if( less(data[child+1], data[min]) )
+		        if( less(_data[child+1], _data[min]) )
 		          min=child+1;
+		      }
 		      else if( child+1<length ) {
-		        if( less(data[child+1], data[min]) )
+		        if( less(_data[child+1], _data[min]) )
 		          min=child+1;
+		      }
 		      return min;
+		    }
-		    void bubble_up(int hole, Pair p) {
+		    void bubbleUp(int hole, Pair p) {
 		      int par = parent(hole);
 		      while( hole>0 && less(p,data[par]) ) {
 		        move(data[par],hole);
 		      while( hole>0 && less(p,_data[par]) ) {
 		        move(_data[par],hole);
 		        hole = par;
 		        par = parent(hole);
+		      }
 		      move(p, hole);
+		    }
-		    void bubble_down(int hole, Pair p, int length) {
+		    void bubbleDown(int hole, Pair p, int length) {
 		      int child = firstChild(hole);
 		      while( child<length && length>1 ) {
 		        child = find_min(child,length);
 		        if( !less(data[child], p) )
 		        child = findMin(child,length);
 		        if( !less(_data[child], p) )
 		          goto ok;
-		        move(data[child], hole);
+		        move(_data[child], hole);
 		        hole = child;
 		        child = firstChild(hole);
+		      }
 		    ok:
 		      move(p, hole);
+		    }
 		    void move(const Pair &p, int i) {
 		      data[i] = p;
 		      iim.set(p.first, i);
 		      _data[i] = p;
 		      _iim.set(p.first, i);
+		    }
 		  public:
 		    /// \brief Insert a pair of item and priority into the heap.
 		    ///
-		    /// Adds \c p.first to the heap with priority \c p.second.
+		    /// This function inserts \c p.first to the heap with priority
 		    /// \c p.second.
 		    /// \param p The pair to insert.
 		    /// \pre \c p.first must not be stored in the heap.
 		    void push(const Pair &p) {
 		      int n = data.size();
 		      data.resize(n+1);
-		      bubble_up(n, p);
+		      int n = _data.size();
 		      _data.resize(n+1);
 		      bubbleUp(n, p);
+		    }
-		    /// \brief Insert an item into the heap with the given heap.
+		    /// \brief Insert an item into the heap with the given priority.
 		    ///
-		    /// Adds \c i to the heap with priority \c p.
+		    /// This function inserts the given item into the heap with the
 		    /// given priority.
 		    /// \param i The item to insert.
 		    /// \param p The priority of the item.
 		    /// \pre \e i must not be stored in the heap.
 		    void push(const Item &i, const Prio &p) { push(Pair(i,p)); }
-		    /// \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 data[0].first; }
 		    /// This function returns the item having minimum priority.
 		    /// \pre The heap must be non-empty.
 		    Item top() const { return _data[0].first; }
-		    /// \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.
-		    Prio prio() const { return data[0].second; }
+		    /// This function returns the minimum priority.
 		    /// \pre The heap must be non-empty.
 		    Prio prio() const { return _data[0].second; }
-		    /// \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() {
 		      int n = data.size()-1;
 		      iim.set(data[0].first, POST_HEAP);
 		      if (n>0) bubble_down(0, data[n], n);
 		      data.pop_back();
 		      int n = _data.size()-1;
 		      _iim.set(_data[0].first, POST_HEAP);
 		      if (n>0) bubbleDown(0, _data[n], n);
 		      _data.pop_back();
+		    }
-		    /// \brief Deletes \c i from the heap.
+		    /// \brief Remove the given item from the heap.
 		    ///
 		    /// This method deletes item \c i from the heap.
 		    /// \param i The item to erase.
-		    /// \pre The item should be in the heap.
+		    /// This function removes the given item from the heap if it is
 		    /// already stored.
 		    /// \param i The item to delete.
 		    /// \pre \e i must be in the heap.
 		    void erase(const Item &i) {
 		      int h = iim[i];
 		      int n = data.size()-1;
-		      iim.set(data[h].first, POST_HEAP);
+		      int h = _iim[i];
 		      int n = _data.size()-1;
 		      _iim.set(_data[h].first, POST_HEAP);
 		      if( h<n ) {
 		        if( less(data[parent(h)], data[n]) )
 		          bubble_down(h, data[n], n);
 		        if( less(_data[parent(h)], _data[n]) )
 		          bubbleDown(h, _data[n], n);
 		        else
-		          bubble_up(h, data[n]);
+		          bubbleUp(h, _data[n]);
+		      }
-		      data.pop_back();
+		      _data.pop_back();
+		    }
-		    /// \brief Returns the priority of \c i.
+		    /// \brief The priority of the given item.
 		    ///
 		    /// This function returns the priority of item \c i.
 		    /// \pre \c i must be in the heap.
 		    /// This function returns the priority of the given item.
 		    /// \param i The item.
 		    /// \pre \e i must be in the heap.
 		    Prio operator[](const Item &i) const {
 		      int idx = iim[i];
 		      return data[idx].second;
 		      int idx = _iim[i];
 		      return _data[idx].second;
+		    }
 		    /// \brief \c i gets to the heap with priority \c p independently
 		    /// if \c i 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 i, \c p) if \c i is not stored
 		    /// in the heap and sets the priority of \c i to \c p 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 i The item.
 		    /// \param p The priority.
 		    void set(const Item &i, const Prio &p) {
-		      int idx = iim[i];
+		      int idx = _iim[i];
 		      if( idx < 0 )
 		        push(i,p);
 		      else if( comp(p, data[idx].second) )
 		        bubble_up(idx, Pair(i,p));
 		      else if( _comp(p, _data[idx].second) )
 		        bubbleUp(idx, Pair(i,p));
 		      else
-		        bubble_down(idx, Pair(i,p), data.size());
+		        bubbleDown(idx, Pair(i,p), _data.size());
+		    }
-		    /// \brief Decreases the priority of \c i to \c p.
+		    /// \brief Decrease the priority of an item to the given value.
 		    ///
 		    /// This method decreases the priority of item \c i to \c p.
 		    /// \pre \c i must be stored in the heap with priority at least \c
-		    /// p relative to \c Compare.
+		    /// This function decreases the priority of an item to the given value.
 		    /// \param i The item.
 		    /// \param p The priority.
 		    /// \pre \e i must be stored in the heap with priority at least \e p.
 		    void decrease(const Item &i, const Prio &p) {
 		      int idx = iim[i];
 		      bubble_up(idx, Pair(i,p));
 		      int idx = _iim[i];
 		      bubbleUp(idx, Pair(i,p));
+		    }
-		    /// \brief Increases the priority of \c i to \c p.
+		    /// \brief Increase the priority of an item to the given value.
 		    ///
 		    /// This method sets the priority of item \c i to \c p.
 		    /// \pre \c i must be stored in the heap with priority at most \c
-		    /// p relative to \c Compare.
+		    /// This function increases the priority of an item to the given value.
 		    /// \param i The item.
 		    /// \param p The priority.
 		    /// \pre \e i must be stored in the heap with priority at most \e p.
 		    void increase(const Item &i, const Prio &p) {
 		      int idx = iim[i];
 		      bubble_down(idx, Pair(i,p), data.size());
 		      int idx = _iim[i];
 		      bubbleDown(idx, Pair(i,p), _data.size());
+		    }
 		    /// \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 i The item.
 		    State state(const Item &i) const {
-		      int s = iim[i];
+		      int s = _iim[i];
 		      if (s>=0) s=0;
 		      return State(s);
+		    }
-		    /// \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) {
 		      switch (st) {
 		        case POST_HEAP:
 		        case PRE_HEAP:
 		          if (state(i) == IN_HEAP) erase(i);
-		          iim[i] = st;
+		          _iim[i] = st;
 		          break;
 		        case IN_HEAP:
 		          break;
+		      }
+		    }
-		    /// \brief Replaces an item in the heap.
+		    /// \brief Replace an item in the heap.
 		    ///
 		    /// The \c i item is replaced with \c j item. The \c i item should
 		    /// be in the heap, while the \c j should be out of the heap. The
 		    /// \c i item will out of the heap and \c j will be in the heap
 		    /// with the same prioriority as prevoiusly the \c i item.
 		    /// This function replaces item \c i with item \c j.
 		    /// Item \c i must be in the heap, while \c j must be out of the heap.
 		    /// After calling this method, item \c i will be out of the
 		    /// heap and \c j will be in the heap with the same prioriority
 		    /// as item \c i had before.
 		    void replace(const Item& i, const Item& j) {
 		      int idx = iim[i];
 		      iim.set(i, iim[j]);
 		      iim.set(j, idx);
 		      data[idx].first = j;
 		      int idx = _iim[i];
 		      _iim.set(i, _iim[j]);
 		      _iim.set(j, idx);
 		      _data[idx].first = j;
+		    }
 		  }; // class FouraryHeap
 		} // namespace lemon
 		#endif // LEMON_FOURARY_HEAP_H

lemon/kary_heap.h

Show inline comments

 		/* -*- 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).
+		 *
 		 * Permission to use, modify and distribute this software is granted
 		 * provided that this copyright notice appears in all copies. For
 		 * precise terms see the accompanying LICENSE file.
+		 *
 		 * This software is provided "AS IS" with no warranty of any kind,
 		 * express or implied, and with no claim as to its suitability for any
 		 * purpose.
+		 *
 		 */
 		#ifndef LEMON_KARY_HEAP_H
 		#define LEMON_KARY_HEAP_H
-		///\ingroup auxdat
+		///\ingroup heaps
 		///\file
-		///\brief Kary Heap implementation.
+		///\brief Fourary heap implementation.
 		#include <iostream>
 		#include <vector>
 		#include <utility>
 		#include <functional>
 		namespace lemon {
-		  ///\ingroup auxdat
+		  /// \ingroup heaps
 		  ///
-		  ///\brief A Kary Heap implementation.
+		  ///\brief K-ary heap data structure.
 		  ///
 		  ///This class implements the \e Kary \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 K-ary \e heap data structure.
 		  /// It fully conforms to the \ref concepts::Heap "heap concept".
 		  ///
 		  ///\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>.
+		  /// The \ref KaryHeap "K-ary heap" is a generalization of the
 		  /// \ref BinHeap "binary heap" structure, its nodes have at most
 		  /// \c K children, instead of two.
 		  /// \ref BinHeap and \ref FouraryHeap are specialized implementations
 		  /// of this structure for <tt>K=2</tt> and <tt>K=4</tt>, respectively.
 		  ///
 		  ///\sa FibHeap
 		  ///\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>.
 		  ///
 		  ///\sa BinHeap
 		  ///\sa FouraryHeap
 		#ifdef DOXYGEN
 		  template <typename PR, typename IM, typename CMP>
 		#else
 		  template <typename PR, typename IM, typename CMP = std::less<PR> >
 		#endif
 		  class KaryHeap {
 		  public:
 		    /// 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;
 		    /// Type of the item-priority pairs.
 		    typedef std::pair<Item,Prio> Pair;
 		    /// Functor type for comparing the priorities.
 		    typedef CMP Compare;
 		  template <typename _Prio, typename _ItemIntMap,
 		            typename _Compare = std::less<_Prio> >
 		  class KaryHeap {
 		  public:
 		    ///\e
 		    typedef _ItemIntMap ItemIntMap;
 		    ///\e
 		    typedef _Prio Prio;
 		    ///\e
 		    typedef typename ItemIntMap::Key Item;
 		    ///\e
 		    typedef std::pair<Item,Prio> Pair;
 		    ///\e
 		    typedef _Compare Compare;
 		    ///\e
-		    /// \brief Type to represent the items states.
+		    /// \brief Type to represent the states of the items.
 		    ///
 		    /// Each Item element have a state associated to it. It may be "in heap",
 		    /// "pre heap" or "post heap". The latter two are indifferent from the
 		    /// 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 ItemIntMap \e should be initialized in such way that it maps
 		    /// PRE_HEAP (-1) to any element to be put in the heap...
 		    /// 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,
 		      PRE_HEAP = -1,
-		      POST_HEAP = -2
+		      IN_HEAP = 0,    ///< = 0.
 		      PRE_HEAP = -1,  ///< = -1.
 		      POST_HEAP = -2  ///< = -2.
 		    };
 		  private:
 		    std::vector<Pair> data;
 		    Compare comp;
 		    ItemIntMap &iim;
 		    int K;
 		    std::vector<Pair> _data;
 		    Compare _comp;
 		    ItemIntMap &_iim;
 		    int _K;
 		  public:
-		    /// \brief The constructor.
+		    /// \brief Constructor.
 		    ///
 		    /// The constructor.
 		    /// \param _iim should be given to the constructor, since it is used
 		    /// internally to handle the cross references. The value of the map
 		    /// should be PRE_HEAP (-1) for each element.
-		    explicit KaryHeap(ItemIntMap &_iim, const int &_K=32) : iim(_iim), K(_K) {}
+		    /// 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 KaryHeap(ItemIntMap &map, int K=32) : _iim(map), _K(K) {}
-		    /// \brief The constructor.
+		    /// \brief Constructor.
 		    ///
 		    /// The constructor.
 		    /// \param _iim should be given to the constructor, since it is used
 		    /// internally to handle the cross references. The value of the map
 		    /// should be PRE_HEAP (-1) for each element.
 		    /// 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.
 		    KaryHeap(ItemIntMap &map, const Compare &comp, int K=32)
 		      : _iim(map), _comp(comp), _K(K) {}
 		    /// \brief The number of items stored in the heap.
 		    ///
 		    /// \param _comp The comparator function object.
 		    KaryHeap(ItemIntMap &_iim, const Compare &_comp, const int &_K=32)
-		      : iim(_iim), comp(_comp), K(_K) {}
+		    /// This function returns the number of items stored in the heap.
 		    int size() const { return _data.size(); }
 		    /// \brief Check if the heap is empty.
 		    ///
 		    /// This function returns \c true if the heap is empty.
 		    bool empty() const { return _data.empty(); }
-		    /// The number of items stored in the heap.
+		    /// \brief Make the heap empty.
 		    ///
 		    /// \brief Returns the number of items stored in the heap.
 		    int size() const { return data.size(); }
 		    /// \brief Checks if the heap stores no items.
 		    ///
 		    /// Returns \c true if and only if the heap stores no items.
 		    bool empty() const { return data.empty(); }
 		    /// \brief Make empty this heap.
 		    ///
 		    /// Make empty this heap. It does not change the cross reference map.
 		    /// If you want to reuse 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.
-		    void clear() { data.clear(); }
+		    /// 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() { _data.clear(); }
 		  private:
 		    int parent(int i) { return (i-1)/K; }
 		    int first_child(int i) { return K*i+1; }
 		    int parent(int i) { return (i-1)/_K; }
 		    int firstChild(int i) { return _K*i+1; }
 		    bool less(const Pair &p1, const Pair &p2) const {
-		      return comp(p1.second, p2.second);
+		      return _comp(p1.second, p2.second);
+		    }
-		    int find_min(const int child, const int length) {
+		    int findMin(const int child, const int length) {
 		      int min=child, i=1;
 		      while( i<K && child+i<length ) {
 		        if( less(data[child+i], data[min]) )
 		      while( i<_K && child+i<length ) {
 		        if( less(_data[child+i], _data[min]) )
 		          min=child+i;
 		        ++i;
+		      }
 		      return min;
+		    }
-		    void bubble_up(int hole, Pair p) {
+		    void bubbleUp(int hole, Pair p) {
 		      int par = parent(hole);
 		      while( hole>0 && less(p,data[par]) ) {
 		        move(data[par],hole);
 		      while( hole>0 && less(p,_data[par]) ) {
 		        move(_data[par],hole);
 		        hole = par;
 		        par = parent(hole);
+		      }
 		      move(p, hole);
+		    }
-		    void bubble_down(int hole, Pair p, int length) {
+		    void bubbleDown(int hole, Pair p, int length) {
 		      if( length>1 ) {
-		        int child = first_child(hole);
+		        int child = firstChild(hole);
 		        while( child<length ) {
 		          child = find_min(child, length);
 		          if( !less(data[child], p) )
 		          child = findMin(child, length);
 		          if( !less(_data[child], p) )
 		            goto ok;
-		          move(data[child], hole);
+		          move(_data[child], hole);
 		          hole = child;
-		          child = first_child(hole);
+		          child = firstChild(hole);
+		        }
+		      }
 		    ok:
 		      move(p, hole);
+		    }
 		    void move(const Pair &p, int i) {
 		      data[i] = p;
 		      iim.set(p.first, i);
 		      _data[i] = p;
 		      _iim.set(p.first, i);
+		    }
 		  public:
 		    /// \brief Insert a pair of item and priority into the heap.
 		    ///
-		    /// Adds \c p.first to the heap with priority \c p.second.
+		    /// This function inserts \c p.first to the heap with priority
 		    /// \c p.second.
 		    /// \param p The pair to insert.
 		    /// \pre \c p.first must not be stored in the heap.
 		    void push(const Pair &p) {
 		      int n = data.size();
 		      data.resize(n+1);
-		      bubble_up(n, p);
+		      int n = _data.size();
 		      _data.resize(n+1);
 		      bubbleUp(n, p);
+		    }
-		    /// \brief Insert an item into the heap with the given heap.
+		    /// \brief Insert an item into the heap with the given priority.
 		    ///
-		    /// Adds \c i to the heap with priority \c p.
+		    /// This function inserts the given item into the heap with the
 		    /// given priority.
 		    /// \param i The item to insert.
 		    /// \param p The priority of the item.
 		    /// \pre \e i must not be stored in the heap.
 		    void push(const Item &i, const Prio &p) { push(Pair(i,p)); }
-		    /// \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 data[0].first; }
 		    /// This function returns the item having minimum priority.
 		    /// \pre The heap must be non-empty.
 		    Item top() const { return _data[0].first; }
-		    /// \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.
-		    Prio prio() const { return data[0].second; }
+		    /// This function returns the minimum priority.
 		    /// \pre The heap must be non-empty.
 		    Prio prio() const { return _data[0].second; }
-		    /// \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() {
 		      int n = data.size()-1;
 		      iim.set(data[0].first, POST_HEAP);
 		      if (n>0) bubble_down(0, data[n], n);
 		      data.pop_back();
 		      int n = _data.size()-1;
 		      _iim.set(_data[0].first, POST_HEAP);
 		      if (n>0) bubbleDown(0, _data[n], n);
 		      _data.pop_back();
+		    }
-		    /// \brief Deletes \c i from the heap.
+		    /// \brief Remove the given item from the heap.
 		    ///
 		    /// This method deletes item \c i from the heap.
 		    /// \param i The item to erase.
-		    /// \pre The item should be in the heap.
+		    /// This function removes the given item from the heap if it is
 		    /// already stored.
 		    /// \param i The item to delete.
 		    /// \pre \e i must be in the heap.
 		    void erase(const Item &i) {
 		      int h = iim[i];
 		      int n = data.size()-1;
-		      iim.set(data[h].first, POST_HEAP);
+		      int h = _iim[i];
 		      int n = _data.size()-1;
 		      _iim.set(_data[h].first, POST_HEAP);
 		      if( h<n ) {
 		        if( less(data[parent(h)], data[n]) )
 		          bubble_down(h, data[n], n);
 		        if( less(_data[parent(h)], _data[n]) )
 		          bubbleDown(h, _data[n], n);
 		        else
-		          bubble_up(h, data[n]);
+		          bubbleUp(h, _data[n]);
+		      }
-		      data.pop_back();
+		      _data.pop_back();
+		    }
 		    /// \brief Returns the priority of \c i.
 		    /// \brief The priority of the given item.
 		    ///
 		    /// This function returns the priority of item \c i.
 		    /// \pre \c i must be in the heap.
 		    /// This function returns the priority of the given item.
 		    /// \param i The item.
 		    /// \pre \e i must be in the heap.
 		    Prio operator[](const Item &i) const {
 		      int idx = iim[i];
 		      return data[idx].second;
 		      int idx = _iim[i];
 		      return _data[idx].second;
+		    }
 		    /// \brief \c i gets to the heap with priority \c p independently
 		    /// if \c i 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 i, \c p) if \c i is not stored
 		    /// in the heap and sets the priority of \c i to \c p 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 i The item.
 		    /// \param p The priority.
 		    void set(const Item &i, const Prio &p) {
-		      int idx = iim[i];
+		      int idx = _iim[i];
 		      if( idx<0 )
 		        push(i,p);
 		      else if( comp(p, data[idx].second) )
 		        bubble_up(idx, Pair(i,p));
 		      else if( _comp(p, _data[idx].second) )
 		        bubbleUp(idx, Pair(i,p));
 		      else
-		        bubble_down(idx, Pair(i,p), data.size());
+		        bubbleDown(idx, Pair(i,p), _data.size());
+		    }
-		    /// \brief Decreases the priority of \c i to \c p.
+		    /// \brief Decrease the priority of an item to the given value.
 		    ///
 		    /// This method decreases the priority of item \c i to \c p.
 		    /// \pre \c i must be stored in the heap with priority at least \c
-		    /// p relative to \c Compare.
+		    /// This function decreases the priority of an item to the given value.
 		    /// \param i The item.
 		    /// \param p The priority.
 		    /// \pre \e i must be stored in the heap with priority at least \e p.
 		    void decrease(const Item &i, const Prio &p) {
 		      int idx = iim[i];
 		      bubble_up(idx, Pair(i,p));
 		      int idx = _iim[i];
 		      bubbleUp(idx, Pair(i,p));
+		    }
-		    /// \brief Increases the priority of \c i to \c p.
+		    /// \brief Increase the priority of an item to the given value.
 		    ///
 		    /// This method sets the priority of item \c i to \c p.
 		    /// \pre \c i must be stored in the heap with priority at most \c
-		    /// p relative to \c Compare.
+		    /// This function increases the priority of an item to the given value.
 		    /// \param i The item.
 		    /// \param p The priority.
 		    /// \pre \e i must be stored in the heap with priority at most \e p.
 		    void increase(const Item &i, const Prio &p) {
 		      int idx = iim[i];
 		      bubble_down(idx, Pair(i,p), data.size());
 		      int idx = _iim[i];
 		      bubbleDown(idx, Pair(i,p), _data.size());
+		    }
 		    /// \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 i The item.
 		    State state(const Item &i) const {
-		      int s = iim[i];
+		      int s = _iim[i];
 		      if (s>=0) s=0;
 		      return State(s);
+		    }
-		    /// \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) {
 		      switch (st) {
 		      case POST_HEAP:
 		      case PRE_HEAP:
 		        if (state(i) == IN_HEAP) erase(i);
 		        iim[i] = st;
 		        break;
 		      case IN_HEAP:
-		        break;
+		        case POST_HEAP:
 		        case PRE_HEAP:
 		          if (state(i) == IN_HEAP) erase(i);
 		          _iim[i] = st;
 		          break;
 		        case IN_HEAP:
 		          break;
+		      }
+		    }
-		    /// \brief Replaces an item in the heap.
+		    /// \brief Replace an item in the heap.
 		    ///
 		    /// The \c i item is replaced with \c j item. The \c i item should
 		    /// be in the heap, while the \c j should be out of the heap. The
 		    /// \c i item will out of the heap and \c j will be in the heap
 		    /// with the same prioriority as prevoiusly the \c i item.
 		    /// This function replaces item \c i with item \c j.
 		    /// Item \c i must be in the heap, while \c j must be out of the heap.
 		    /// After calling this method, item \c i will be out of the
 		    /// heap and \c j will be in the heap with the same prioriority
 		    /// as item \c i had before.
 		    void replace(const Item& i, const Item& j) {
 		      int idx=iim[i];
 		      iim.set(i, iim[j]);
 		      iim.set(j, idx);
 		      data[idx].first=j;
 		      int idx=_iim[i];
 		      _iim.set(i, _iim[j]);
 		      _iim.set(j, idx);
 		      _data[idx].first=j;
+		    }
 		  }; // class KaryHeap
 		} // namespace lemon
 		#endif // LEMON_KARY_HEAP_H

lemon/pairing_heap.h

Show inline comments

 		/* -*- 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).
+		 *
 		 * Permission to use, modify and distribute this software is granted
 		 * provided that this copyright notice appears in all copies. For
 		 * precise terms see the accompanying LICENSE file.
+		 *
 		 * This software is provided "AS IS" with no warranty of any kind,
 		 * express or implied, and with no claim as to its suitability for any
 		 * purpose.
+		 *
 		 */
 		#ifndef LEMON_PAIRING_HEAP_H
 		#define LEMON_PAIRING_HEAP_H
 		///\file
 		///\ingroup auxdat
 		///\brief Pairing Heap implementation.
 		///\ingroup heaps
 		///\brief Pairing heap implementation.
 		#include <vector>
 		#include <utility>
 		#include <functional>
 		#include <lemon/math.h>
 		namespace lemon {
-		  /// \ingroup auxdat
+		  /// \ingroup heaps
 		  ///
 		  ///\brief Pairing Heap.
 		  ///
 		  ///This class implements the \e Pairing \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 pairing \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 Pairing
 		  ///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 pairing 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 PairingHeap {
 		  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;
 		    ItemIntMap &iimap;
 		    Compare comp;
-		    int num_items;
+		    std::vector<store> _data;
 		    int _min;
 		    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 PairingHeap(ItemIntMap &map)
 		      : _min(0), _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 PairingHeap(ItemIntMap &_iimap)
 		      : minimum(0), iimap(_iimap), num_items(0) {}
 		    /// \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.
 		    PairingHeap(ItemIntMap &_iimap, const Compare &_comp)
 		      : minimum(0), iimap(_iimap), comp(_comp), num_items(0) {}
 		    /// 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.
 		    PairingHeap(ItemIntMap &map, const Compare &comp)
 		      : _min(0), _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;
+		      _data.clear();
 		      _min = 0;
 		      _num_items = 0;
+		    }
 		    /// \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].child=-1;
 		        container[i].left_child=false;
 		        container[i].degree=0;
 		        container[i].in=true;
 		        _data[i].parent=_data[i].child=-1;
 		        _data[i].left_child=false;
 		        _data[i].degree=0;
 		        _data[i].in=true;
+		      }
-		      container[i].prio=value;
+		      _data[i].prio=value;
 		      if ( num_items!=0 ) {
 		        if ( comp( value, container[minimum].prio) ) {
 		          fuse(i,minimum);
 		          minimum=i;
 		      if ( _num_items!=0 ) {
 		        if ( _comp( value, _data[_min].prio) ) {
 		          fuse(i,_min);
 		          _min=i;
+		        }
-		        else fuse(minimum,i);
+		        else fuse(_min,i);
+		      }
-		      else minimum=i;
+		      else _min=i;
-		      ++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.
 		    const 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() {
-		      int TreeArray[num_items];
+		      int TreeArray[_num_items];
 		      int i=0, num_child=0, child_right = 0;
-		      container[minimum].in=false;
+		      _data[_min].in=false;
 		      if( -1!=container[minimum].child ) {
 		        i=container[minimum].child;
 		      if( -1!=_data[_min].child ) {
 		        i=_data[_min].child;
 		        TreeArray[num_child] = i;
 		        container[i].parent = -1;
 		        container[minimum].child = -1;
 		        _data[i].parent = -1;
 		        _data[_min].child = -1;
 		        ++num_child;
 		        int ch=-1;
 		        while( container[i].child!=-1 ) {
 		          ch=container[i].child;
-		          if( container[ch].left_child && i==container[ch].parent ) {
+		        while( _data[i].child!=-1 ) {
 		          ch=_data[i].child;
 		          if( _data[ch].left_child && i==_data[ch].parent ) {
 		            i=ch;
 		            //break;
 		          } else {
 		            if( container[ch].left_child ) {
 		              child_right=container[ch].parent;
 		              container[ch].parent = i;
 		              --container[i].degree;
 		            if( _data[ch].left_child ) {
 		              child_right=_data[ch].parent;
 		              _data[ch].parent = i;
 		              --_data[i].degree;
+		            }
 		            else {
 		              child_right=ch;
 		              container[i].child=-1;
 		              container[i].degree=0;
 		              _data[i].child=-1;
 		              _data[i].degree=0;
+		            }
-		            container[child_right].parent = -1;
+		            _data[child_right].parent = -1;
 		            TreeArray[num_child] = child_right;
 		            i = child_right;
 		            ++num_child;
+		          }
+		        }
 		        int other;
 		        for( i=0; i<num_child-1; i+=2 ) {
 		          if ( !comp(container[TreeArray[i]].prio,
 		                     container[TreeArray[i+1]].prio) ) {
 		          if ( !_comp(_data[TreeArray[i]].prio,
 		                     _data[TreeArray[i+1]].prio) ) {
 		            other=TreeArray[i];
 		            TreeArray[i]=TreeArray[i+1];
 		            TreeArray[i+1]=other;
+		          }
 		          fuse( TreeArray[i], TreeArray[i+1] );
+		        }
 		        i = (0==(num_child % 2)) ? num_child-2 : num_child-1;
 		        while(i>=2) {
 		          if ( comp(container[TreeArray[i]].prio,
 		                    container[TreeArray[i-2]].prio) ) {
 		          if ( _comp(_data[TreeArray[i]].prio,
 		                    _data[TreeArray[i-2]].prio) ) {
 		            other=TreeArray[i];
 		            TreeArray[i]=TreeArray[i-2];
 		            TreeArray[i-2]=other;
+		          }
 		          fuse( TreeArray[i-2], TreeArray[i] );
 		          i-=2;
+		        }
-		        minimum = TreeArray[0];
+		        _min = TreeArray[0];
+		      }
 		      if ( 0==num_child ) {
-		        minimum = container[minimum].child;
+		        _min = _data[_min].child;
+		      }
-		      if (minimum >= 0) container[minimum].left_child = false;
+		      if (_min >= 0) _data[_min].left_child = false;
-		      --num_items;
+		      --_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 Pairing 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];
 		      container[i].prio=value;
-		      int p=container[i].parent;
+		      int i=_iim[item];
 		      _data[i].prio=value;
 		      int p=_data[i].parent;
 		      if( container[i].left_child && i!=container[p].child ) {
 		        p=container[p].parent;
 		      if( _data[i].left_child && i!=_data[p].child ) {
 		        p=_data[p].parent;
+		      }
-		      if ( p!=-1 && comp(value,container[p].prio) ) {
+		      if ( p!=-1 && _comp(value,_data[p].prio) ) {
 		        cut(i,p);
 		        if ( comp(container[minimum].prio,value) ) {
 		          fuse(minimum,i);
 		        if ( _comp(_data[_min].prio,value) ) {
 		          fuse(_min,i);
 		        } else {
 		          fuse(i,minimum);
 		          minimum=i;
 		          fuse(i,_min);
 		          _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) {
 		      switch (st) {
 		      case POST_HEAP:
 		      case PRE_HEAP:
 		        if (state(i) == IN_HEAP) erase(i);
-		        iimap[i]=st;
+		        _iim[i]=st;
 		        break;
 		      case IN_HEAP:
 		        break;
+		      }
+		    }
 		  private:
 		    void cut(int a, int b) {
 		      int child_a;
-		      switch (container[a].degree) {
+		      switch (_data[a].degree) {
 		        case 2:
 		          child_a = container[container[a].child].parent;
 		          if( container[a].left_child ) {
 		            container[child_a].left_child=true;
 		            container[b].child=child_a;
-		            container[child_a].parent=container[a].parent;
+		          child_a = _data[_data[a].child].parent;
 		          if( _data[a].left_child ) {
 		            _data[child_a].left_child=true;
 		            _data[b].child=child_a;
 		            _data[child_a].parent=_data[a].parent;
+		          }
 		          else {
 		            container[child_a].left_child=false;
 		            container[child_a].parent=b;
 		            if( a!=container[b].child )
 		              container[container[b].child].parent=child_a;
 		            _data[child_a].left_child=false;
 		            _data[child_a].parent=b;
 		            if( a!=_data[b].child )
 		              _data[_data[b].child].parent=child_a;
 		            else
-		              container[b].child=child_a;
+		              _data[b].child=child_a;
+		          }
 		          --container[a].degree;
 		          container[container[a].child].parent=a;
 		          --_data[a].degree;
 		          _data[_data[a].child].parent=a;
 		          break;
 		        case 1:
 		          child_a = container[a].child;
 		          if( !container[child_a].left_child ) {
 		            --container[a].degree;
 		            if( container[a].left_child ) {
 		              container[child_a].left_child=true;
 		              container[child_a].parent=container[a].parent;
-		              container[b].child=child_a;
+		          child_a = _data[a].child;
 		          if( !_data[child_a].left_child ) {
 		            --_data[a].degree;
 		            if( _data[a].left_child ) {
 		              _data[child_a].left_child=true;
 		              _data[child_a].parent=_data[a].parent;
 		              _data[b].child=child_a;
+		            }
 		            else {
 		              container[child_a].left_child=false;
 		              container[child_a].parent=b;
 		              if( a!=container[b].child )
 		                container[container[b].child].parent=child_a;
 		              _data[child_a].left_child=false;
 		              _data[child_a].parent=b;
 		              if( a!=_data[b].child )
 		                _data[_data[b].child].parent=child_a;
 		              else
-		                container[b].child=child_a;
+		                _data[b].child=child_a;
+		            }
-		            container[a].child=-1;
+		            _data[a].child=-1;
+		          }
 		          else {
 		            --container[b].degree;
 		            if( container[a].left_child ) {
 		              container[b].child =
 		                (1==container[b].degree) ? container[a].parent : -1;
 		            --_data[b].degree;
 		            if( _data[a].left_child ) {
 		              _data[b].child =
 		                (1==_data[b].degree) ? _data[a].parent : -1;
 		            } else {
 		              if (1==container[b].degree)
 		                container[container[b].child].parent=b;
 		              if (1==_data[b].degree)
 		                _data[_data[b].child].parent=b;
 		              else
-		                container[b].child=-1;
+		                _data[b].child=-1;
+		            }
+		          }
 		          break;
 		        case 0:
 		          --container[b].degree;
 		          if( container[a].left_child ) {
 		            container[b].child =
 		              (0!=container[b].degree) ? container[a].parent : -1;
 		          --_data[b].degree;
 		          if( _data[a].left_child ) {
 		            _data[b].child =
 		              (0!=_data[b].degree) ? _data[a].parent : -1;
 		          } else {
 		            if( 0!=container[b].degree )
 		              container[container[b].child].parent=b;
 		            if( 0!=_data[b].degree )
 		              _data[_data[b].child].parent=b;
 		            else
-		              container[b].child=-1;
+		              _data[b].child=-1;
+		          }
 		          break;
+		      }
 		      container[a].parent=-1;
 		      container[a].left_child=false;
 		      _data[a].parent=-1;
 		      _data[a].left_child=false;
+		    }
 		    void fuse(int a, int b) {
 		      int child_a = container[a].child;
 		      int child_b = container[b].child;
 		      container[a].child=b;
 		      container[b].parent=a;
-		      container[b].left_child=true;
+		      int child_a = _data[a].child;
 		      int child_b = _data[b].child;
 		      _data[a].child=b;
 		      _data[b].parent=a;
 		      _data[b].left_child=true;
 		      if( -1!=child_a ) {
 		        container[b].child=child_a;
 		        container[child_a].parent=b;
 		        container[child_a].left_child=false;
 		        ++container[b].degree;
 		        _data[b].child=child_a;
 		        _data[child_a].parent=b;
 		        _data[child_a].left_child=false;
 		        ++_data[b].degree;
 		        if( -1!=child_b ) {
 		           container[b].child=child_b;
 		           container[child_b].parent=child_a;
 		           _data[b].child=child_b;
 		           _data[child_b].parent=child_a;
+		        }
+		      }
-		      else { ++container[a].degree; }
+		      else { ++_data[a].degree; }
+		    }
 		    class store {
 		      friend class PairingHeap;
 		      Item name;
 		      int parent;
 		      int child;
 		      bool left_child;
 		      int degree;
 		      bool in;
 		      Prio prio;
 		      store() : parent(-1), child(-1), left_child(false), degree(0), in(true) {}
 		    };
 		  };
 		} //namespace lemon
 		#endif //LEMON_PAIRING_HEAP_H

0 comments (0 inline)

RhodeCode

Login to your account