LEMON/LEMON-main Changeset - r717:684964884a2e

Repositories » LEMON » LEMON-main

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

Changeset - r717:684964884a2e

« 715:ece801
« 716:f47b6c

719:ba79e8 »

r717:684964884a2e

Fri, 25 Sep 2009 09:13:03

[Not Reviewed]

0 comments (0 inline)

alpar (Alpar Juttner)
alpar@cs.elte.hu

Merge

0 22 9

merge default

4 files changed with 6144 insertions and 314 deletions:

lemon/bellman_ford.h

1100

lemon/binom_heap.h

445

lemon/bucket_heap.h

594

lemon/fib_heap.h

475

lemon/fourary_heap.h

342

lemon/kary_heap.h

352

lemon/pairing_heap.h

474

lemon/radix_heap.h

438

test/bellman_ford_test.cc

283

doc/groups.dox

100

lemon/Makefile.am

lemon/bfs.h

lemon/bin_heap.h

112

lemon/bits/edge_set_extender.h

lemon/bits/graph_extender.h

lemon/circulation.h

lemon/concepts/heap.h

lemon/dfs.h

lemon/dijkstra.h

lemon/dim2.h

lemon/gomory_hu.h

lemon/maps.h

943

lemon/min_cost_arborescence.h

lemon/preflow.h

test/CMakeLists.txt

test/Makefile.am

test/circulation_test.cc

test/heap_test.cc

test/maps_test.cc

222

test/preflow_test.cc

tools/lemon-0.x-to-1.x.sh

↑ Collapse diff ↑

lemon/bellman_ford.h

Show inline comments

 		/* -*- C++ -*-
+		 *
 		 * This file is a part of LEMON, a generic C++ optimization library
+		 *
 		 * Copyright (C) 2003-2008
 		 * 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_BELLMAN_FORD_H
 		#define LEMON_BELLMAN_FORD_H
 		/// \ingroup shortest_path
 		/// \file
 		/// \brief Bellman-Ford algorithm.
 		#include <lemon/bits/path_dump.h>
 		#include <lemon/core.h>
 		#include <lemon/error.h>
 		#include <lemon/maps.h>
 		#include <lemon/path.h>
 		#include <limits>
 		namespace lemon {
 		  /// \brief Default OperationTraits for the BellmanFord algorithm class.
 		  ///
 		  /// This operation traits class defines all computational operations
 		  /// and constants that are used in the Bellman-Ford algorithm.
 		  /// The default implementation is based on the \c numeric_limits class.
 		  /// If the numeric type does not have infinity value, then the maximum
 		  /// value is used as extremal infinity value.
 		  template <
 		    typename V,
 		    bool has_inf = std::numeric_limits<V>::has_infinity>
 		  struct BellmanFordDefaultOperationTraits {
 		    /// \e
 		    typedef V Value;
 		    /// \brief Gives back the zero value of the type.
 		    static Value zero() {
 		      return static_cast<Value>(0);
+		    }
 		    /// \brief Gives back the positive infinity value of the type.
 		    static Value infinity() {
 		      return std::numeric_limits<Value>::infinity();
+		    }
 		    /// \brief Gives back the sum of the given two elements.
 		    static Value plus(const Value& left, const Value& right) {
 		      return left + right;
+		    }
 		    /// \brief Gives back \c true only if the first value is less than
 		    /// the second.
 		    static bool less(const Value& left, const Value& right) {
 		      return left < right;
+		    }
 		  };
 		  template <typename V>
 		  struct BellmanFordDefaultOperationTraits<V, false> {
 		    typedef V Value;
 		    static Value zero() {
 		      return static_cast<Value>(0);
+		    }
 		    static Value infinity() {
 		      return std::numeric_limits<Value>::max();
+		    }
 		    static Value plus(const Value& left, const Value& right) {
 		      if (left == infinity() || right == infinity()) return infinity();
 		      return left + right;
+		    }
 		    static bool less(const Value& left, const Value& right) {
 		      return left < right;
+		    }
 		  };
 		  /// \brief Default traits class of BellmanFord class.
 		  ///
 		  /// Default traits class of BellmanFord class.
 		  /// \param GR The type of the digraph.
 		  /// \param LEN The type of the length map.
 		  template<typename GR, typename LEN>
 		  struct BellmanFordDefaultTraits {
 		    /// The type of the digraph the algorithm runs on.
 		    typedef GR Digraph;
 		    /// \brief The type of the map that stores the arc lengths.
 		    ///
 		    /// The type of the map that stores the arc lengths.
 		    /// It must conform to the \ref concepts::ReadMap "ReadMap" concept.
 		    typedef LEN LengthMap;
 		    /// The type of the arc lengths.
 		    typedef typename LEN::Value Value;
 		    /// \brief Operation traits for Bellman-Ford algorithm.
 		    ///
 		    /// It defines the used operations and the infinity value for the
 		    /// given \c Value type.
 		    /// \see BellmanFordDefaultOperationTraits
 		    typedef BellmanFordDefaultOperationTraits<Value> OperationTraits;
 		    /// \brief The type of the map that stores the last arcs of the
 		    /// shortest paths.
 		    ///
 		    /// The type of the map that stores the last
 		    /// arcs of the shortest paths.
 		    /// It must conform to the \ref concepts::WriteMap "WriteMap" concept.
 		    typedef typename GR::template NodeMap<typename GR::Arc> PredMap;
 		    /// \brief Instantiates a \c PredMap.
 		    ///
 		    /// This function instantiates a \ref PredMap.
 		    /// \param g is the digraph to which we would like to define the
 		    /// \ref PredMap.
 		    static PredMap *createPredMap(const GR& g) {
 		      return new PredMap(g);
+		    }
 		    /// \brief The type of the map that stores the distances of the nodes.
 		    ///
 		    /// The type of the map that stores the distances of the nodes.
 		    /// It must conform to the \ref concepts::WriteMap "WriteMap" concept.
 		    typedef typename GR::template NodeMap<typename LEN::Value> DistMap;
 		    /// \brief Instantiates a \c DistMap.
 		    ///
 		    /// This function instantiates a \ref DistMap.
 		    /// \param g is the digraph to which we would like to define the
 		    /// \ref DistMap.
 		    static DistMap *createDistMap(const GR& g) {
 		      return new DistMap(g);
+		    }
 		  };
 		  /// \brief %BellmanFord algorithm class.
 		  ///
 		  /// \ingroup shortest_path
 		  /// This class provides an efficient implementation of the Bellman-Ford
 		  /// algorithm. The maximum time complexity of the algorithm is
 		  /// <tt>O(ne)</tt>.
 		  ///
 		  /// The Bellman-Ford algorithm solves the single-source shortest path
 		  /// problem when the arcs can have negative lengths, but the digraph
 		  /// should not contain directed cycles with negative total length.
 		  /// If all arc costs are non-negative, consider to use the Dijkstra
 		  /// algorithm instead, since it is more efficient.
 		  ///
 		  /// The arc lengths are passed to the algorithm using a
 		  /// \ref concepts::ReadMap "ReadMap", so it is easy to change it to any
 		  /// kind of length. The type of the length values is determined by the
 		  /// \ref concepts::ReadMap::Value "Value" type of the length map.
 		  ///
 		  /// There is also a \ref bellmanFord() "function-type interface" for the
 		  /// Bellman-Ford algorithm, which is convenient in the simplier cases and
 		  /// it can be used easier.
 		  ///
 		  /// \tparam GR The type of the digraph the algorithm runs on.
 		  /// The default type is \ref ListDigraph.
 		  /// \tparam LEN A \ref concepts::ReadMap "readable" arc map that specifies
 		  /// the lengths of the arcs. The default map type is
 		  /// \ref concepts::Digraph::ArcMap "GR::ArcMap<int>".
 		#ifdef DOXYGEN
 		  template <typename GR, typename LEN, typename TR>
 		#else
 		  template <typename GR=ListDigraph,
 		            typename LEN=typename GR::template ArcMap<int>,
 		            typename TR=BellmanFordDefaultTraits<GR,LEN> >
 		#endif
 		  class BellmanFord {
 		  public:
 		    ///The type of the underlying digraph.
 		    typedef typename TR::Digraph Digraph;
 		    /// \brief The type of the arc lengths.
 		    typedef typename TR::LengthMap::Value Value;
 		    /// \brief The type of the map that stores the arc lengths.
 		    typedef typename TR::LengthMap LengthMap;
 		    /// \brief The type of the map that stores the last
 		    /// arcs of the shortest paths.
 		    typedef typename TR::PredMap PredMap;
 		    /// \brief The type of the map that stores the distances of the nodes.
 		    typedef typename TR::DistMap DistMap;
 		    /// The type of the paths.
 		    typedef PredMapPath<Digraph, PredMap> Path;
 		    ///\brief The \ref BellmanFordDefaultOperationTraits
 		    /// "operation traits class" of the algorithm.
 		    typedef typename TR::OperationTraits OperationTraits;
 		    ///The \ref BellmanFordDefaultTraits "traits class" of the algorithm.
 		    typedef TR Traits;
 		  private:
 		    typedef typename Digraph::Node Node;
 		    typedef typename Digraph::NodeIt NodeIt;
 		    typedef typename Digraph::Arc Arc;
 		    typedef typename Digraph::OutArcIt OutArcIt;
 		    // Pointer to the underlying digraph.
 		    const Digraph *_gr;
 		    // Pointer to the length map
 		    const LengthMap *_length;
 		    // Pointer to the map of predecessors arcs.
 		    PredMap *_pred;
 		    // Indicates if _pred is locally allocated (true) or not.
 		    bool _local_pred;
 		    // Pointer to the map of distances.
 		    DistMap *_dist;
 		    // Indicates if _dist is locally allocated (true) or not.
 		    bool _local_dist;
 		    typedef typename Digraph::template NodeMap<bool> MaskMap;
 		    MaskMap *_mask;
 		    std::vector<Node> _process;
 		    // Creates the maps if necessary.
 		    void create_maps() {
 		      if(!_pred) {
 			_local_pred = true;
 			_pred = Traits::createPredMap(*_gr);
+		      }
 		      if(!_dist) {
 			_local_dist = true;
 			_dist = Traits::createDistMap(*_gr);
+		      }
 		      _mask = new MaskMap(*_gr, false);
+		    }
 		  public :
 		    typedef BellmanFord Create;
 		    /// \name Named Template Parameters
 		    ///@{
 		    template <class T>
 		    struct SetPredMapTraits : public Traits {
 		      typedef T PredMap;
 		      static PredMap *createPredMap(const Digraph&) {
 		        LEMON_ASSERT(false, "PredMap is not initialized");
 		        return 0; // ignore warnings
+		      }
 		    };
 		    /// \brief \ref named-templ-param "Named parameter" for setting
 		    /// \c PredMap type.
 		    ///
 		    /// \ref named-templ-param "Named parameter" for setting
 		    /// \c PredMap type.
 		    /// It must conform to the \ref concepts::WriteMap "WriteMap" concept.
 		    template <class T>
 		    struct SetPredMap
 		      : public BellmanFord< Digraph, LengthMap, SetPredMapTraits<T> > {
 		      typedef BellmanFord< Digraph, LengthMap, SetPredMapTraits<T> > Create;
 		    };
 		    template <class T>
 		    struct SetDistMapTraits : public Traits {
 		      typedef T DistMap;
 		      static DistMap *createDistMap(const Digraph&) {
 		        LEMON_ASSERT(false, "DistMap is not initialized");
 		        return 0; // ignore warnings
+		      }
 		    };
 		    /// \brief \ref named-templ-param "Named parameter" for setting
 		    /// \c DistMap type.
 		    ///
 		    /// \ref named-templ-param "Named parameter" for setting
 		    /// \c DistMap type.
 		    /// It must conform to the \ref concepts::WriteMap "WriteMap" concept.
 		    template <class T>
 		    struct SetDistMap
 		      : public BellmanFord< Digraph, LengthMap, SetDistMapTraits<T> > {
 		      typedef BellmanFord< Digraph, LengthMap, SetDistMapTraits<T> > Create;
 		    };
 		    template <class T>
 		    struct SetOperationTraitsTraits : public Traits {
 		      typedef T OperationTraits;
 		    };
 		    /// \brief \ref named-templ-param "Named parameter" for setting
 		    /// \c OperationTraits type.
 		    ///
 		    /// \ref named-templ-param "Named parameter" for setting
 		    /// \c OperationTraits type.
 		    /// For more information see \ref BellmanFordDefaultOperationTraits.
 		    template <class T>
 		    struct SetOperationTraits
 		      : public BellmanFord< Digraph, LengthMap, SetOperationTraitsTraits<T> > {
 		      typedef BellmanFord< Digraph, LengthMap, SetOperationTraitsTraits<T> >
 		      Create;
 		    };
 		    ///@}
 		  protected:
 		    BellmanFord() {}
 		  public:
 		    /// \brief Constructor.
 		    ///
 		    /// Constructor.
 		    /// \param g The digraph the algorithm runs on.
 		    /// \param length The length map used by the algorithm.
 		    BellmanFord(const Digraph& g, const LengthMap& length) :
 		      _gr(&g), _length(&length),
 		      _pred(0), _local_pred(false),
 		      _dist(0), _local_dist(false), _mask(0) {}
 		    ///Destructor.
 		    ~BellmanFord() {
 		      if(_local_pred) delete _pred;
 		      if(_local_dist) delete _dist;
 		      if(_mask) delete _mask;
+		    }
 		    /// \brief Sets the length map.
 		    ///
 		    /// Sets the length map.
 		    /// \return <tt>(*this)</tt>
 		    BellmanFord &lengthMap(const LengthMap &map) {
 		      _length = &map;
 		      return *this;
+		    }
 		    /// \brief Sets the map that stores the predecessor arcs.
 		    ///
 		    /// Sets the map that stores the predecessor arcs.
 		    /// If you don't use this function before calling \ref run()
 		    /// or \ref init(), an instance will be allocated automatically.
 		    /// The destructor deallocates this automatically allocated map,
 		    /// of course.
 		    /// \return <tt>(*this)</tt>
 		    BellmanFord &predMap(PredMap &map) {
 		      if(_local_pred) {
 			delete _pred;
 			_local_pred=false;
+		      }
 		      _pred = &map;
 		      return *this;
+		    }
 		    /// \brief Sets the map that stores the distances of the nodes.
 		    ///
 		    /// Sets the map that stores the distances of the nodes calculated
 		    /// by the algorithm.
 		    /// If you don't use this function before calling \ref run()
 		    /// or \ref init(), an instance will be allocated automatically.
 		    /// The destructor deallocates this automatically allocated map,
 		    /// of course.
 		    /// \return <tt>(*this)</tt>
 		    BellmanFord &distMap(DistMap &map) {
 		      if(_local_dist) {
 			delete _dist;
 			_local_dist=false;
+		      }
 		      _dist = &map;
 		      return *this;
+		    }
 		    /// \name Execution Control
 		    /// The simplest way to execute the Bellman-Ford algorithm is to use
 		    /// one of the member functions called \ref run().\n
 		    /// If you need better control on the execution, you have to call
 		    /// \ref init() first, then you can add several source nodes
 		    /// with \ref addSource(). Finally the actual path computation can be
 		    /// performed with \ref start(), \ref checkedStart() or
 		    /// \ref limitedStart().
 		    ///@{
 		    /// \brief Initializes the internal data structures.
 		    ///
 		    /// Initializes the internal data structures. The optional parameter
 		    /// is the initial distance of each node.
 		    void init(const Value value = OperationTraits::infinity()) {
 		      create_maps();
 		      for (NodeIt it(*_gr); it != INVALID; ++it) {
 			_pred->set(it, INVALID);
 			_dist->set(it, value);
+		      }
 		      _process.clear();
 		      if (OperationTraits::less(value, OperationTraits::infinity())) {
 			for (NodeIt it(*_gr); it != INVALID; ++it) {
 			  _process.push_back(it);
 			  _mask->set(it, true);
+			}
+		      }
+		    }
 		    /// \brief Adds a new source node.
 		    ///
 		    /// This function adds a new source node. The optional second parameter
 		    /// is the initial distance of the node.
 		    void addSource(Node source, Value dst = OperationTraits::zero()) {
 		      _dist->set(source, dst);
 		      if (!(*_mask)[source]) {
 			_process.push_back(source);
 			_mask->set(source, true);
+		      }
+		    }
 		    /// \brief Executes one round from the Bellman-Ford algorithm.
 		    ///
 		    /// If the algoritm calculated the distances in the previous round
 		    /// exactly for the paths of at most \c k arcs, then this function
 		    /// will calculate the distances exactly for the paths of at most
 		    /// <tt>k+1</tt> arcs. Performing \c k iterations using this function
 		    /// calculates the shortest path distances exactly for the paths
 		    /// consisting of at most \c k arcs.
 		    ///
 		    /// \warning The paths with limited arc number cannot be retrieved
 		    /// easily with \ref path() or \ref predArc() functions. If you also
 		    /// need the shortest paths and not only the distances, you should
 		    /// store the \ref predMap() "predecessor map" after each iteration
 		    /// and build the path manually.
 		    ///
 		    /// \return \c true when the algorithm have not found more shorter
 		    /// paths.
 		    ///
 		    /// \see ActiveIt
 		    bool processNextRound() {
 		      for (int i = 0; i < int(_process.size()); ++i) {
 			_mask->set(_process[i], false);
+		      }
 		      std::vector<Node> nextProcess;
 		      std::vector<Value> values(_process.size());
 		      for (int i = 0; i < int(_process.size()); ++i) {
 			values[i] = (*_dist)[_process[i]];
+		      }
 		      for (int i = 0; i < int(_process.size()); ++i) {
 			for (OutArcIt it(*_gr, _process[i]); it != INVALID; ++it) {
 			  Node target = _gr->target(it);
 			  Value relaxed = OperationTraits::plus(values[i], (*_length)[it]);
 			  if (OperationTraits::less(relaxed, (*_dist)[target])) {
 			    _pred->set(target, it);
 			    _dist->set(target, relaxed);
 			    if (!(*_mask)[target]) {
 			      _mask->set(target, true);
 			      nextProcess.push_back(target);
+			    }
+			  }
+			}
+		      }
 		      _process.swap(nextProcess);
 		      return _process.empty();
+		    }
 		    /// \brief Executes one weak round from the Bellman-Ford algorithm.
 		    ///
 		    /// If the algorithm calculated the distances in the previous round
 		    /// at least for the paths of at most \c k arcs, then this function
 		    /// will calculate the distances at least for the paths of at most
 		    /// <tt>k+1</tt> arcs.
 		    /// This function does not make it possible to calculate the shortest
 		    /// path distances exactly for paths consisting of at most \c k arcs,
 		    /// this is why it is called weak round.
 		    ///
 		    /// \return \c true when the algorithm have not found more shorter
 		    /// paths.
 		    ///
 		    /// \see ActiveIt
 		    bool processNextWeakRound() {
 		      for (int i = 0; i < int(_process.size()); ++i) {
 			_mask->set(_process[i], false);
+		      }
 		      std::vector<Node> nextProcess;
 		      for (int i = 0; i < int(_process.size()); ++i) {
 			for (OutArcIt it(*_gr, _process[i]); it != INVALID; ++it) {
 			  Node target = _gr->target(it);
 			  Value relaxed =
 			    OperationTraits::plus((*_dist)[_process[i]], (*_length)[it]);
 			  if (OperationTraits::less(relaxed, (*_dist)[target])) {
 			    _pred->set(target, it);
 			    _dist->set(target, relaxed);
 			    if (!(*_mask)[target]) {
 			      _mask->set(target, true);
 			      nextProcess.push_back(target);
+			    }
+			  }
+			}
+		      }
 		      _process.swap(nextProcess);
 		      return _process.empty();
+		    }
 		    /// \brief Executes the algorithm.
 		    ///
 		    /// Executes the algorithm.
 		    ///
 		    /// This method runs the Bellman-Ford algorithm from the root node(s)
 		    /// in order to compute the shortest path to each node.
 		    ///
 		    /// The algorithm computes
 		    /// - the shortest path tree (forest),
 		    /// - the distance of each node from the root(s).
 		    ///
 		    /// \pre init() must be called and at least one root node should be
 		    /// added with addSource() before using this function.
 		    void start() {
 		      int num = countNodes(*_gr) - 1;
 		      for (int i = 0; i < num; ++i) {
 			if (processNextWeakRound()) break;
+		      }
+		    }
 		    /// \brief Executes the algorithm and checks the negative cycles.
 		    ///
 		    /// Executes the algorithm and checks the negative cycles.
 		    ///
 		    /// This method runs the Bellman-Ford algorithm from the root node(s)
 		    /// in order to compute the shortest path to each node and also checks
 		    /// if the digraph contains cycles with negative total length.
 		    ///
 		    /// The algorithm computes
 		    /// - the shortest path tree (forest),
 		    /// - the distance of each node from the root(s).
 		    ///
 		    /// \return \c false if there is a negative cycle in the digraph.
 		    ///
 		    /// \pre init() must be called and at least one root node should be
 		    /// added with addSource() before using this function.
 		    bool checkedStart() {
 		      int num = countNodes(*_gr);
 		      for (int i = 0; i < num; ++i) {
 			if (processNextWeakRound()) return true;
+		      }
 		      return _process.empty();
+		    }
 		    /// \brief Executes the algorithm with arc number limit.
 		    ///
 		    /// Executes the algorithm with arc number limit.
 		    ///
 		    /// This method runs the Bellman-Ford algorithm from the root node(s)
 		    /// in order to compute the shortest path distance for each node
 		    /// using only the paths consisting of at most \c num arcs.
 		    ///
 		    /// The algorithm computes
 		    /// - the limited distance of each node from the root(s),
 		    /// - the predecessor arc for each node.
 		    ///
 		    /// \warning The paths with limited arc number cannot be retrieved
 		    /// easily with \ref path() or \ref predArc() functions. If you also
 		    /// need the shortest paths and not only the distances, you should
 		    /// store the \ref predMap() "predecessor map" after each iteration
 		    /// and build the path manually.
 		    ///
 		    /// \pre init() must be called and at least one root node should be
 		    /// added with addSource() before using this function.
 		    void limitedStart(int num) {
 		      for (int i = 0; i < num; ++i) {
 			if (processNextRound()) break;
+		      }
+		    }
 		    /// \brief Runs the algorithm from the given root node.
 		    ///
 		    /// This method runs the Bellman-Ford algorithm from the given root
 		    /// node \c s in order to compute the shortest path to each node.
 		    ///
 		    /// The algorithm computes
 		    /// - the shortest path tree (forest),
 		    /// - the distance of each node from the root(s).
 		    ///
 		    /// \note bf.run(s) is just a shortcut of the following code.
 		    /// \code
 		    ///   bf.init();
 		    ///   bf.addSource(s);
 		    ///   bf.start();
 		    /// \endcode
 		    void run(Node s) {
 		      init();
 		      addSource(s);
 		      start();
+		    }
 		    /// \brief Runs the algorithm from the given root node with arc
 		    /// number limit.
 		    ///
 		    /// This method runs the Bellman-Ford algorithm from the given root
 		    /// node \c s in order to compute the shortest path distance for each
 		    /// node using only the paths consisting of at most \c num arcs.
 		    ///
 		    /// The algorithm computes
 		    /// - the limited distance of each node from the root(s),
 		    /// - the predecessor arc for each node.
 		    ///
 		    /// \warning The paths with limited arc number cannot be retrieved
 		    /// easily with \ref path() or \ref predArc() functions. If you also
 		    /// need the shortest paths and not only the distances, you should
 		    /// store the \ref predMap() "predecessor map" after each iteration
 		    /// and build the path manually.
 		    ///
 		    /// \note bf.run(s, num) is just a shortcut of the following code.
 		    /// \code
 		    ///   bf.init();
 		    ///   bf.addSource(s);
 		    ///   bf.limitedStart(num);
 		    /// \endcode
 		    void run(Node s, int num) {
 		      init();
 		      addSource(s);
 		      limitedStart(num);
+		    }
 		    ///@}
 		    /// \brief LEMON iterator for getting the active nodes.
 		    ///
 		    /// This class provides a common style LEMON iterator that traverses
 		    /// the active nodes of the Bellman-Ford algorithm after the last
 		    /// phase. These nodes should be checked in the next phase to
 		    /// find augmenting arcs outgoing from them.
 		    class ActiveIt {
 		    public:
 		      /// \brief Constructor.
 		      ///
 		      /// Constructor for getting the active nodes of the given BellmanFord
 		      /// instance.
 		      ActiveIt(const BellmanFord& algorithm) : _algorithm(&algorithm)
+		      {
 		        _index = _algorithm->_process.size() - 1;
+		      }
 		      /// \brief Invalid constructor.
 		      ///
 		      /// Invalid constructor.
 		      ActiveIt(Invalid) : _algorithm(0), _index(-1) {}
 		      /// \brief Conversion to \c Node.
 		      ///
 		      /// Conversion to \c Node.
 		      operator Node() const {
 		        return _index >= 0 ? _algorithm->_process[_index] : INVALID;
+		      }
 		      /// \brief Increment operator.
 		      ///
 		      /// Increment operator.
 		      ActiveIt& operator++() {
 		        --_index;
 		        return *this;
+		      }
 		      bool operator==(const ActiveIt& it) const {
 		        return static_cast<Node>(*this) == static_cast<Node>(it);
+		      }
 		      bool operator!=(const ActiveIt& it) const {
 		        return static_cast<Node>(*this) != static_cast<Node>(it);
+		      }
 		      bool operator<(const ActiveIt& it) const {
 		        return static_cast<Node>(*this) < static_cast<Node>(it);
+		      }
 		    private:
 		      const BellmanFord* _algorithm;
 		      int _index;
 		    };
 		    /// \name Query Functions
 		    /// The result of the Bellman-Ford algorithm can be obtained using these
 		    /// functions.\n
 		    /// Either \ref run() or \ref init() should be called before using them.
 		    ///@{
 		    /// \brief The shortest path to the given node.
 		    ///
 		    /// Gives back the shortest path to the given node from the root(s).
 		    ///
 		    /// \warning \c t should be reached from the root(s).
 		    ///
 		    /// \pre Either \ref run() or \ref init() must be called before
 		    /// using this function.
 		    Path path(Node t) const
+		    {
 		      return Path(*_gr, *_pred, t);
+		    }
 		    /// \brief The distance of the given node from the root(s).
 		    ///
 		    /// Returns the distance of the given node from the root(s).
 		    ///
 		    /// \warning If node \c v is not reached from the root(s), then
 		    /// the return value of this function is undefined.
 		    ///
 		    /// \pre Either \ref run() or \ref init() must be called before
 		    /// using this function.
 		    Value dist(Node v) const { return (*_dist)[v]; }
 		    /// \brief Returns the 'previous arc' of the shortest path tree for
 		    /// the given node.
 		    ///
 		    /// This function returns the 'previous arc' of the shortest path
 		    /// tree for node \c v, i.e. it returns the last arc of a
 		    /// shortest path from a root to \c v. It is \c INVALID if \c v
 		    /// is not reached from the root(s) or if \c v is a root.
 		    ///
 		    /// The shortest path tree used here is equal to the shortest path
 		    /// tree used in \ref predNode() and \predMap().
 		    ///
 		    /// \pre Either \ref run() or \ref init() must be called before
 		    /// using this function.
 		    Arc predArc(Node v) const { return (*_pred)[v]; }
 		    /// \brief Returns the 'previous node' of the shortest path tree for
 		    /// the given node.
 		    ///
 		    /// This function returns the 'previous node' of the shortest path
 		    /// tree for node \c v, i.e. it returns the last but one node of
 		    /// a shortest path from a root to \c v. It is \c INVALID if \c v
 		    /// is not reached from the root(s) or if \c v is a root.
 		    ///
 		    /// The shortest path tree used here is equal to the shortest path
 		    /// tree used in \ref predArc() and \predMap().
 		    ///
 		    /// \pre Either \ref run() or \ref init() must be called before
 		    /// using this function.
 		    Node predNode(Node v) const {
 		      return (*_pred)[v] == INVALID ? INVALID : _gr->source((*_pred)[v]);
+		    }
 		    /// \brief Returns a const reference to the node map that stores the
 		    /// distances of the nodes.
 		    ///
 		    /// Returns a const reference to the node map that stores the distances
 		    /// of the nodes calculated by the algorithm.
 		    ///
 		    /// \pre Either \ref run() or \ref init() must be called before
 		    /// using this function.
 		    const DistMap &distMap() const { return *_dist;}
 		    /// \brief Returns a const reference to the node map that stores the
 		    /// predecessor arcs.
 		    ///
 		    /// Returns a const reference to the node map that stores the predecessor
 		    /// arcs, which form the shortest path tree (forest).
 		    ///
 		    /// \pre Either \ref run() or \ref init() must be called before
 		    /// using this function.
 		    const PredMap &predMap() const { return *_pred; }
 		    /// \brief Checks if a node is reached from the root(s).
 		    ///
 		    /// Returns \c true if \c v is reached from the root(s).
 		    ///
 		    /// \pre Either \ref run() or \ref init() must be called before
 		    /// using this function.
 		    bool reached(Node v) const {
 		      return (*_dist)[v] != OperationTraits::infinity();
+		    }
 		    /// \brief Gives back a negative cycle.
 		    ///
 		    /// This function gives back a directed cycle with negative total
 		    /// length if the algorithm has already found one.
 		    /// Otherwise it gives back an empty path.
 		    lemon::Path<Digraph> negativeCycle() {
 		      typename Digraph::template NodeMap<int> state(*_gr, -1);
 		      lemon::Path<Digraph> cycle;
 		      for (int i = 0; i < int(_process.size()); ++i) {
 		        if (state[_process[i]] != -1) continue;
 		        for (Node v = _process[i]; (*_pred)[v] != INVALID;
 		             v = _gr->source((*_pred)[v])) {
 		          if (state[v] == i) {
 		            cycle.addFront((*_pred)[v]);
 		            for (Node u = _gr->source((*_pred)[v]); u != v;
 		                 u = _gr->source((*_pred)[u])) {
 		              cycle.addFront((*_pred)[u]);
+		            }
 		            return cycle;
+		          }
 		          else if (state[v] >= 0) {
 		            break;
+		          }
 		          state[v] = i;
+		        }
+		      }
 		      return cycle;
+		    }
 		    ///@}
 		  };
 		  /// \brief Default traits class of bellmanFord() function.
 		  ///
 		  /// Default traits class of bellmanFord() function.
 		  /// \tparam GR The type of the digraph.
 		  /// \tparam LEN The type of the length map.
 		  template <typename GR, typename LEN>
 		  struct BellmanFordWizardDefaultTraits {
 		    /// The type of the digraph the algorithm runs on.
 		    typedef GR Digraph;
 		    /// \brief The type of the map that stores the arc lengths.
 		    ///
 		    /// The type of the map that stores the arc lengths.
 		    /// It must meet the \ref concepts::ReadMap "ReadMap" concept.
 		    typedef LEN LengthMap;
 		    /// The type of the arc lengths.
 		    typedef typename LEN::Value Value;
 		    /// \brief Operation traits for Bellman-Ford algorithm.
 		    ///
 		    /// It defines the used operations and the infinity value for the
 		    /// given \c Value type.
 		    /// \see BellmanFordDefaultOperationTraits
 		    typedef BellmanFordDefaultOperationTraits<Value> OperationTraits;
 		    /// \brief The type of the map that stores the last
 		    /// arcs of the shortest paths.
 		    ///
 		    /// The type of the map that stores the last arcs of the shortest paths.
 		    /// It must conform to the \ref concepts::WriteMap "WriteMap" concept.
 		    typedef typename GR::template NodeMap<typename GR::Arc> PredMap;
 		    /// \brief Instantiates a \c PredMap.
 		    ///
 		    /// This function instantiates a \ref PredMap.
 		    /// \param g is the digraph to which we would like to define the
 		    /// \ref PredMap.
 		    static PredMap *createPredMap(const GR &g) {
 		      return new PredMap(g);
+		    }
 		    /// \brief The type of the map that stores the distances of the nodes.
 		    ///
 		    /// The type of the map that stores the distances of the nodes.
 		    /// It must conform to the \ref concepts::WriteMap "WriteMap" concept.
 		    typedef typename GR::template NodeMap<Value> DistMap;
 		    /// \brief Instantiates a \c DistMap.
 		    ///
 		    /// This function instantiates a \ref DistMap.
 		    /// \param g is the digraph to which we would like to define the
 		    /// \ref DistMap.
 		    static DistMap *createDistMap(const GR &g) {
 		      return new DistMap(g);
+		    }
 		    ///The type of the shortest paths.
 		    ///The type of the shortest paths.
 		    ///It must meet the \ref concepts::Path "Path" concept.
 		    typedef lemon::Path<Digraph> Path;
 		  };
 		  /// \brief Default traits class used by BellmanFordWizard.
 		  ///
 		  /// Default traits class used by BellmanFordWizard.
 		  /// \tparam GR The type of the digraph.
 		  /// \tparam LEN The type of the length map.
 		  template <typename GR, typename LEN>
 		  class BellmanFordWizardBase
 		    : public BellmanFordWizardDefaultTraits<GR, LEN> {
 		    typedef BellmanFordWizardDefaultTraits<GR, LEN> Base;
 		  protected:
 		    // Type of the nodes in the digraph.
 		    typedef typename Base::Digraph::Node Node;
 		    // Pointer to the underlying digraph.
 		    void *_graph;
 		    // Pointer to the length map
 		    void *_length;
 		    // Pointer to the map of predecessors arcs.
 		    void *_pred;
 		    // Pointer to the map of distances.
 		    void *_dist;
 		    //Pointer to the shortest path to the target node.
 		    void *_path;
 		    //Pointer to the distance of the target node.
 		    void *_di;
 		    public:
 		    /// Constructor.
 		    /// This constructor does not require parameters, it initiates
 		    /// all of the attributes to default values \c 0.
 		    BellmanFordWizardBase() :
 		      _graph(0), _length(0), _pred(0), _dist(0), _path(0), _di(0) {}
 		    /// Constructor.
 		    /// This constructor requires two parameters,
 		    /// others are initiated to \c 0.
 		    /// \param gr The digraph the algorithm runs on.
 		    /// \param len The length map.
 		    BellmanFordWizardBase(const GR& gr,
 					  const LEN& len) :
 		      _graph(reinterpret_cast<void*>(const_cast<GR*>(&gr))),
 		      _length(reinterpret_cast<void*>(const_cast<LEN*>(&len))),
 		      _pred(0), _dist(0), _path(0), _di(0) {}
 		  };
 		  /// \brief Auxiliary class for the function-type interface of the
 		  /// \ref BellmanFord "Bellman-Ford" algorithm.
 		  ///
 		  /// This auxiliary class is created to implement the
 		  /// \ref bellmanFord() "function-type interface" of the
 		  /// \ref BellmanFord "Bellman-Ford" algorithm.
 		  /// It does not have own \ref run() method, it uses the
 		  /// functions and features of the plain \ref BellmanFord.
 		  ///
 		  /// This class should only be used through the \ref bellmanFord()
 		  /// function, which makes it easier to use the algorithm.
 		  template<class TR>
 		  class BellmanFordWizard : public TR {
 		    typedef TR Base;
 		    typedef typename TR::Digraph Digraph;
 		    typedef typename Digraph::Node Node;
 		    typedef typename Digraph::NodeIt NodeIt;
 		    typedef typename Digraph::Arc Arc;
 		    typedef typename Digraph::OutArcIt ArcIt;
 		    typedef typename TR::LengthMap LengthMap;
 		    typedef typename LengthMap::Value Value;
 		    typedef typename TR::PredMap PredMap;
 		    typedef typename TR::DistMap DistMap;
 		    typedef typename TR::Path Path;
 		  public:
 		    /// Constructor.
 		    BellmanFordWizard() : TR() {}
 		    /// \brief Constructor that requires parameters.
 		    ///
 		    /// Constructor that requires parameters.
 		    /// These parameters will be the default values for the traits class.
 		    /// \param gr The digraph the algorithm runs on.
 		    /// \param len The length map.
 		    BellmanFordWizard(const Digraph& gr, const LengthMap& len)
 		      : TR(gr, len) {}
 		    /// \brief Copy constructor
 		    BellmanFordWizard(const TR &b) : TR(b) {}
 		    ~BellmanFordWizard() {}
 		    /// \brief Runs the Bellman-Ford algorithm from the given source node.
 		    ///
 		    /// This method runs the Bellman-Ford algorithm from the given source
 		    /// node in order to compute the shortest path to each node.
 		    void run(Node s) {
 		      BellmanFord<Digraph,LengthMap,TR>
 			bf(*reinterpret_cast<const Digraph*>(Base::_graph),
 		           *reinterpret_cast<const LengthMap*>(Base::_length));
 		      if (Base::_pred) bf.predMap(*reinterpret_cast<PredMap*>(Base::_pred));
 		      if (Base::_dist) bf.distMap(*reinterpret_cast<DistMap*>(Base::_dist));
 		      bf.run(s);
+		    }
 		    /// \brief Runs the Bellman-Ford algorithm to find the shortest path
 		    /// between \c s and \c t.
 		    ///
 		    /// This method runs the Bellman-Ford algorithm from node \c s
 		    /// in order to compute the shortest path to node \c t.
 		    /// Actually, it computes the shortest path to each node, but using
 		    /// this function you can retrieve the distance and the shortest path
 		    /// for a single target node easier.
 		    ///
 		    /// \return \c true if \c t is reachable form \c s.
 		    bool run(Node s, Node t) {
 		      BellmanFord<Digraph,LengthMap,TR>
 		        bf(*reinterpret_cast<const Digraph*>(Base::_graph),
 		           *reinterpret_cast<const LengthMap*>(Base::_length));
 		      if (Base::_pred) bf.predMap(*reinterpret_cast<PredMap*>(Base::_pred));
 		      if (Base::_dist) bf.distMap(*reinterpret_cast<DistMap*>(Base::_dist));
 		      bf.run(s);
 		      if (Base::_path) *reinterpret_cast<Path*>(Base::_path) = bf.path(t);
 		      if (Base::_di) *reinterpret_cast<Value*>(Base::_di) = bf.dist(t);
 		      return bf.reached(t);
+		    }
 		    template<class T>
 		    struct SetPredMapBase : public Base {
 		      typedef T PredMap;
 		      static PredMap *createPredMap(const Digraph &) { return 0; };
 		      SetPredMapBase(const TR &b) : TR(b) {}
 		    };
 		    /// \brief \ref named-templ-param "Named parameter" for setting
 		    /// the predecessor map.
 		    ///
 		    /// \ref named-templ-param "Named parameter" for setting
 		    /// the map that stores the predecessor arcs of the nodes.
 		    template<class T>
 		    BellmanFordWizard<SetPredMapBase<T> > predMap(const T &t) {
 		      Base::_pred=reinterpret_cast<void*>(const_cast<T*>(&t));
 		      return BellmanFordWizard<SetPredMapBase<T> >(*this);
+		    }
 		    template<class T>
 		    struct SetDistMapBase : public Base {
 		      typedef T DistMap;
 		      static DistMap *createDistMap(const Digraph &) { return 0; };
 		      SetDistMapBase(const TR &b) : TR(b) {}
 		    };
 		    /// \brief \ref named-templ-param "Named parameter" for setting
 		    /// the distance map.
 		    ///
 		    /// \ref named-templ-param "Named parameter" for setting
 		    /// the map that stores the distances of the nodes calculated
 		    /// by the algorithm.
 		    template<class T>
 		    BellmanFordWizard<SetDistMapBase<T> > distMap(const T &t) {
 		      Base::_dist=reinterpret_cast<void*>(const_cast<T*>(&t));
 		      return BellmanFordWizard<SetDistMapBase<T> >(*this);
+		    }
 		    template<class T>
 		    struct SetPathBase : public Base {
 		      typedef T Path;
 		      SetPathBase(const TR &b) : TR(b) {}
 		    };
 		    /// \brief \ref named-func-param "Named parameter" for getting
 		    /// the shortest path to the target node.
 		    ///
 		    /// \ref named-func-param "Named parameter" for getting
 		    /// the shortest path to the target node.
 		    template<class T>
 		    BellmanFordWizard<SetPathBase<T> > path(const T &t)
+		    {
 		      Base::_path=reinterpret_cast<void*>(const_cast<T*>(&t));
 		      return BellmanFordWizard<SetPathBase<T> >(*this);
+		    }
 		    /// \brief \ref named-func-param "Named parameter" for getting
 		    /// the distance of the target node.
 		    ///
 		    /// \ref named-func-param "Named parameter" for getting
 		    /// the distance of the target node.
 		    BellmanFordWizard dist(const Value &d)
+		    {
 		      Base::_di=reinterpret_cast<void*>(const_cast<Value*>(&d));
 		      return *this;
+		    }
 		  };
 		  /// \brief Function type interface for the \ref BellmanFord "Bellman-Ford"
 		  /// algorithm.
 		  ///
 		  /// \ingroup shortest_path
 		  /// Function type interface for the \ref BellmanFord "Bellman-Ford"
 		  /// algorithm.
 		  ///
 		  /// This function also has several \ref named-templ-func-param
 		  /// "named parameters", they are declared as the members of class
 		  /// \ref BellmanFordWizard.
 		  /// The following examples show how to use these parameters.
 		  /// \code
 		  ///   // Compute shortest path from node s to each node
 		  ///   bellmanFord(g,length).predMap(preds).distMap(dists).run(s);
 		  ///
 		  ///   // Compute shortest path from s to t
 		  ///   bool reached = bellmanFord(g,length).path(p).dist(d).run(s,t);
 		  /// \endcode
 		  /// \warning Don't forget to put the \ref BellmanFordWizard::run() "run()"
 		  /// to the end of the parameter list.
 		  /// \sa BellmanFordWizard
 		  /// \sa BellmanFord
 		  template<typename GR, typename LEN>
 		  BellmanFordWizard<BellmanFordWizardBase<GR,LEN> >
 		  bellmanFord(const GR& digraph,
 			      const LEN& length)
+		  {
 		    return BellmanFordWizard<BellmanFordWizardBase<GR,LEN> >(digraph, length);
+		  }
 		} //END OF NAMESPACE LEMON
 		#endif

lemon/binom_heap.h

Show inline comments

 		/* -*- mode: C++; indent-tabs-mode: nil; -*-
+		 *
 		 * This file is a part of LEMON, a generic C++ optimization library.
+		 *
 		 * 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 heaps
 		///\brief Binomial Heap implementation.
 		#include <vector>
 		#include <utility>
 		#include <functional>
 		#include <lemon/math.h>
 		#include <lemon/counter.h>
 		namespace lemon {
 		  /// \ingroup heaps
 		  ///
 		  ///\brief Binomial heap data structure.
 		  ///
 		  /// 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 of these operations,
 		  /// it is better to use other heap structure, e.g. \ref BinHeap
 		  /// "binary heap".
 		  ///
 		  /// \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 PR, typename IM, typename CMP>
 		#else
 		  template <typename PR, typename IM, typename CMP = std::less<PR> >
 		#endif
 		  class BinomHeap {
 		  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;
 		    /// 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> _data;
 		    int _min, _head;
 		    ItemIntMap &_iim;
 		    Compare _comp;
 		    int _num_items;
 		  public:
 		    /// \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 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.
 		    /// \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.
 		    ///
 		    /// This function returns the number of items stored in the heap.
 		    int size() const { return _num_items; }
 		    /// \brief Check if the heap is empty.
 		    ///
 		    /// This function returns \c true if the heap is empty.
 		    bool empty() const { return _num_items==0; }
 		    /// \brief Make the heap empty.
 		    ///
 		    /// 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(); _min=0; _num_items=0; _head=-1;
+		    }
 		    /// \brief Set the priority of an item or insert it, if it is
 		    /// not stored in the heap.
 		    ///
 		    /// 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=_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 Insert an item into the heap with the given priority.
 		    ///
 		    /// 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=_iim[item];
 		      if ( i<0 ) {
 		        int s=_data.size();
 		        _iim.set( item,s );
 		        Store st;
 		        st.name=item;
 		        st.prio=value;
 		        _data.push_back(st);
 		        i=s;
+		      }
 		      else {
 		        _data[i].parent=_data[i].right_neighbor=_data[i].child=-1;
 		        _data[i].degree=0;
 		        _data[i].in=true;
 		        _data[i].prio=value;
+		      }
 		      if( 0==_num_items ) {
 		        _head=i;
 		        _min=i;
 		      } else {
 		        merge(i);
 		        if( _comp(_data[i].prio, _data[_min].prio) ) _min=i;
+		      }
 		      ++_num_items;
+		    }
 		    /// \brief Return the item having minimum priority.
 		    ///
 		    /// This function returns the item having minimum priority.
 		    /// \pre The heap must be non-empty.
 		    Item top() const { return _data[_min].name; }
 		    /// \brief The minimum priority.
 		    ///
 		    /// This function returns the minimum priority.
 		    /// \pre The heap must be non-empty.
 		    Prio prio() const { return _data[_min].prio; }
 		    /// \brief The priority of the given item.
 		    ///
 		    /// 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 _data[_iim[item]].prio;
+		    }
 		    /// \brief Remove the item having minimum priority.
 		    ///
 		    /// This function removes the item having minimum priority.
 		    /// \pre The heap must be non-empty.
 		    void pop() {
 		      _data[_min].in=false;
 		      int head_child=-1;
 		      if ( _data[_min].child!=-1 ) {
 		        int child=_data[_min].child;
 		        int neighb;
 		        while( child!=-1 ) {
 		          neighb=_data[child].right_neighbor;
 		          _data[child].parent=-1;
 		          _data[child].right_neighbor=head_child;
 		          head_child=child;
 		          child=neighb;
+		        }
+		      }
 		      if ( _data[_head].right_neighbor==-1 ) {
 		        // there was only one root
 		        _head=head_child;
+		      }
 		      else {
 		        // there were more roots
 		        if( _head!=_min )  { unlace(_min); }
 		        else { _head=_data[_head].right_neighbor; }
 		        merge(head_child);
+		      }
 		      _min=findMin();
 		      --_num_items;
+		    }
 		    /// \brief Remove the given item from the heap.
 		    ///
 		    /// 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=_iim[item];
 		      if ( i >= 0 && _data[i].in ) {
 		        decrease( item, _data[_min].prio-1 );
 		        pop();
+		      }
+		    }
 		    /// \brief Decrease the priority of an item to the given value.
 		    ///
 		    /// 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=_iim[item];
 		      int p=_data[i].parent;
 		      _data[i].prio=value;
 		      while( p!=-1 && _comp(value, _data[p].prio) ) {
 		        _data[i].name=_data[p].name;
 		        _data[i].prio=_data[p].prio;
 		        _data[p].name=item;
 		        _data[p].prio=value;
 		        _iim[_data[i].name]=i;
 		        i=p;
 		        p=_data[p].parent;
+		      }
 		      _iim[item]=i;
 		      if ( _comp(value, _data[_min].prio) ) _min=i;
+		    }
 		    /// \brief Increase the priority of an item to the given value.
 		    ///
 		    /// 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 Return the state of an item.
 		    ///
 		    /// 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=_iim[item];
 		      if( i>=0 ) {
 		        if ( _data[i].in ) i=0;
 		        else i=-2;
+		      }
 		      return State(i);
+		    }
 		    /// \brief Set the state of an item in the heap.
 		    ///
 		    /// 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;
+		      }
+		    }
 		  private:
 		    // Find the minimum of the roots
 		    int findMin() {
 		      if( _head!=-1 ) {
 		        int min_loc=_head, min_val=_data[_head].prio;
 		        for( int x=_data[_head].right_neighbor; x!=-1;
 		             x=_data[x].right_neighbor ) {
 		          if( _comp( _data[x].prio,min_val ) ) {
 		            min_val=_data[x].prio;
 		            min_loc=x;
+		          }
+		        }
 		        return min_loc;
+		      }
 		      else return -1;
+		    }
 		    // Merge the heap with another heap starting at the given position
 		    void merge(int a) {
 		      if( _head==-1 || a==-1 ) return;
 		      if( _data[a].right_neighbor==-1 &&
 		          _data[a].degree<=_data[_head].degree ) {
 		        _data[a].right_neighbor=_head;
 		        _head=a;
 		      } else {
 		        interleave(a);
+		      }
 		      if( _data[_head].right_neighbor==-1 ) return;
 		      int x=_head;
 		      int x_prev=-1, x_next=_data[x].right_neighbor;
 		      while( x_next!=-1 ) {
 		        if( _data[x].degree!=_data[x_next].degree ||
 		            ( _data[x_next].right_neighbor!=-1 &&
 		              _data[_data[x_next].right_neighbor].degree==_data[x].degree ) ) {
 		          x_prev=x;
 		          x=x_next;
+		        }
 		        else {
 		          if( _comp(_data[x_next].prio,_data[x].prio) ) {
 		            if( x_prev==-1 ) {
 		              _head=x_next;
 		            } else {
 		              _data[x_prev].right_neighbor=x_next;
+		            }
 		            fuse(x,x_next);
 		            x=x_next;
+		          }
 		          else {
 		            _data[x].right_neighbor=_data[x_next].right_neighbor;
 		            fuse(x_next,x);
+		          }
+		        }
 		        x_next=_data[x].right_neighbor;
+		      }
+		    }
 		    // Interleave the elements of the given list into the list of the roots
 		    void interleave(int a) {
 		      int p=_head, q=a;
 		      int curr=_data.size();
 		      _data.push_back(Store());
 		      while( p!=-1 || q!=-1 ) {
 		        if( q==-1 || ( p!=-1 && _data[p].degree<_data[q].degree ) ) {
 		          _data[curr].right_neighbor=p;
 		          curr=p;
 		          p=_data[p].right_neighbor;
+		        }
 		        else {
 		          _data[curr].right_neighbor=q;
 		          curr=q;
 		          q=_data[q].right_neighbor;
+		        }
+		      }
 		      _head=_data.back().right_neighbor;
 		      _data.pop_back();
+		    }
 		    // Lace node a under node b
 		    void fuse(int a, int b) {
 		      _data[a].parent=b;
 		      _data[a].right_neighbor=_data[b].child;
 		      _data[b].child=a;
 		      ++_data[b].degree;
+		    }
 		    // Unlace node a (if it has siblings)
 		    void unlace(int a) {
 		      int neighb=_data[a].right_neighbor;
 		      int other=_head;
 		      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/bucket_heap.h

Show inline comments

 		/* -*- mode: C++; indent-tabs-mode: nil; -*-
+		 *
 		 * This file is a part of LEMON, a generic C++ optimization library.
+		 *
 		 * 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_BUCKET_HEAP_H
 		#define LEMON_BUCKET_HEAP_H
 		///\ingroup heaps
 		///\file
 		///\brief Bucket heap implementation.
 		#include <vector>
 		#include <utility>
 		#include <functional>
 		namespace lemon {
 		  namespace _bucket_heap_bits {
 		    template <bool MIN>
 		    struct DirectionTraits {
 		      static bool less(int left, int right) {
 		        return left < right;
+		      }
 		      static void increase(int& value) {
 		        ++value;
+		      }
 		    };
 		    template <>
 		    struct DirectionTraits<false> {
 		      static bool less(int left, int right) {
 		        return left > right;
+		      }
 		      static void increase(int& value) {
 		        --value;
+		      }
 		    };
+		  }
 		  /// \ingroup heaps
 		  ///
 		  /// \brief Bucket heap data structure.
 		  ///
 		  /// This class implements the \e bucket \e heap data structure.
 		  /// It practically conforms to the \ref concepts::Heap "heap concept",
 		  /// but it has some limitations.
 		  ///
 		  /// The bucket heap is a very simple structure. It can store only
 		  /// \c int priorities and it maintains a list of items for each priority
 		  /// in the range <tt>[0..C)</tt>. So it should only be used when the
 		  /// priorities are small. It is not intended to use as a Dijkstra heap.
 		  ///
 		  /// \tparam IM A read-writable item map with \c int values, used
 		  /// internally to handle the cross references.
 		  /// \tparam MIN Indicate if the heap is a \e min-heap or a \e max-heap.
 		  /// The default is \e min-heap. If this parameter is set to \c false,
 		  /// then the comparison is reversed, so the top(), prio() and pop()
 		  /// functions deal with the item having maximum priority instead of the
 		  /// minimum.
 		  ///
 		  /// \sa SimpleBucketHeap
 		  template <typename IM, bool MIN = true>
 		  class BucketHeap {
 		  public:
 		    /// Type of the item-int map.
 		    typedef IM ItemIntMap;
 		    /// Type of the priorities.
 		    typedef int 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;
 		  private:
 		    typedef _bucket_heap_bits::DirectionTraits<MIN> Direction;
 		  public:
 		    /// \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.
 		    };
 		  public:
 		    /// \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 BucketHeap(ItemIntMap &map) : _iim(map), _minimum(0) {}
 		    /// \brief The number of items stored in the heap.
 		    ///
 		    /// 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(); }
 		    /// \brief Make the heap empty.
 		    ///
 		    /// 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(); _first.clear(); _minimum = 0;
+		    }
 		  private:
 		    void relocateLast(int idx) {
 		      if (idx + 1 < int(_data.size())) {
 		        _data[idx] = _data.back();
 		        if (_data[idx].prev != -1) {
 		          _data[_data[idx].prev].next = idx;
 		        } else {
 		          _first[_data[idx].value] = idx;
+		        }
 		        if (_data[idx].next != -1) {
 		          _data[_data[idx].next].prev = idx;
+		        }
 		        _iim[_data[idx].item] = idx;
+		      }
 		      _data.pop_back();
+		    }
 		    void unlace(int idx) {
 		      if (_data[idx].prev != -1) {
 		        _data[_data[idx].prev].next = _data[idx].next;
 		      } else {
 		        _first[_data[idx].value] = _data[idx].next;
+		      }
 		      if (_data[idx].next != -1) {
 		        _data[_data[idx].next].prev = _data[idx].prev;
+		      }
+		    }
 		    void lace(int idx) {
 		      if (int(_first.size()) <= _data[idx].value) {
 		        _first.resize(_data[idx].value + 1, -1);
+		      }
 		      _data[idx].next = _first[_data[idx].value];
 		      if (_data[idx].next != -1) {
 		        _data[_data[idx].next].prev = idx;
+		      }
 		      _first[_data[idx].value] = idx;
 		      _data[idx].prev = -1;
+		    }
 		  public:
 		    /// \brief Insert a pair of item and priority into the heap.
 		    ///
 		    /// 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) {
 		      push(p.first, p.second);
+		    }
 		    /// \brief Insert an item into the heap with the given priority.
 		    ///
 		    /// 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) {
 		      int idx = _data.size();
 		      _iim[i] = idx;
 		      _data.push_back(BucketItem(i, p));
 		      lace(idx);
 		      if (Direction::less(p, _minimum)) {
 		        _minimum = p;
+		      }
+		    }
 		    /// \brief Return the item having minimum priority.
 		    ///
 		    /// This function returns the item having minimum priority.
 		    /// \pre The heap must be non-empty.
 		    Item top() const {
 		      while (_first[_minimum] == -1) {
 		        Direction::increase(_minimum);
+		      }
 		      return _data[_first[_minimum]].item;
+		    }
 		    /// \brief The minimum priority.
 		    ///
 		    /// This function returns the minimum priority.
 		    /// \pre The heap must be non-empty.
 		    Prio prio() const {
 		      while (_first[_minimum] == -1) {
 		        Direction::increase(_minimum);
+		      }
 		      return _minimum;
+		    }
 		    /// \brief Remove the item having minimum priority.
 		    ///
 		    /// This function removes the item having minimum priority.
 		    /// \pre The heap must be non-empty.
 		    void pop() {
 		      while (_first[_minimum] == -1) {
 		        Direction::increase(_minimum);
+		      }
 		      int idx = _first[_minimum];
 		      _iim[_data[idx].item] = -2;
 		      unlace(idx);
 		      relocateLast(idx);
+		    }
 		    /// \brief Remove the given item from 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 idx = _iim[i];
 		      _iim[_data[idx].item] = -2;
 		      unlace(idx);
 		      relocateLast(idx);
+		    }
 		    /// \brief The priority of the given item.
 		    ///
 		    /// 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].value;
+		    }
 		    /// \brief Set the priority of an item or insert it, if it is
 		    /// not stored in the heap.
 		    ///
 		    /// 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];
 		      if (idx < 0) {
 		        push(i, p);
 		      } else if (Direction::less(p, _data[idx].value)) {
 		        decrease(i, p);
 		      } else {
 		        increase(i, p);
+		      }
+		    }
 		    /// \brief Decrease the priority of an item to the given value.
 		    ///
 		    /// 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];
 		      unlace(idx);
 		      _data[idx].value = p;
 		      if (Direction::less(p, _minimum)) {
 		        _minimum = p;
+		      }
 		      lace(idx);
+		    }
 		    /// \brief Increase the priority of an item to the given value.
 		    ///
 		    /// 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];
 		      unlace(idx);
 		      _data[idx].value = p;
 		      lace(idx);
+		    }
 		    /// \brief Return the state of an item.
 		    ///
 		    /// 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 idx = _iim[i];
 		      if (idx >= 0) idx = 0;
 		      return State(idx);
+		    }
 		    /// \brief Set the state of an item in the heap.
 		    ///
 		    /// 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;
+		      }
+		    }
 		  private:
 		    struct BucketItem {
 		      BucketItem(const Item& _item, int _value)
 		        : item(_item), value(_value) {}
 		      Item item;
 		      int value;
 		      int prev, next;
 		    };
 		    ItemIntMap& _iim;
 		    std::vector<int> _first;
 		    std::vector<BucketItem> _data;
 		    mutable int _minimum;
 		  }; // class BucketHeap
 		  /// \ingroup heaps
 		  ///
 		  /// \brief Simplified bucket heap data structure.
 		  ///
 		  /// This class implements a simplified \e bucket \e heap data
 		  /// structure. It does not provide some functionality, but it is
 		  /// faster and simpler than BucketHeap. The main difference is
 		  /// that BucketHeap stores a doubly-linked list for each key while
 		  /// this class stores only simply-linked lists. It supports erasing
 		  /// only for the item having minimum priority and it does not support
 		  /// key increasing and decreasing.
 		  ///
 		  /// Note that this implementation does not conform to the
 		  /// \ref concepts::Heap "heap concept" due to the lack of some
 		  /// functionality.
 		  ///
 		  /// \tparam IM A read-writable item map with \c int values, used
 		  /// internally to handle the cross references.
 		  /// \tparam MIN Indicate if the heap is a \e min-heap or a \e max-heap.
 		  /// The default is \e min-heap. If this parameter is set to \c false,
 		  /// then the comparison is reversed, so the top(), prio() and pop()
 		  /// functions deal with the item having maximum priority instead of the
 		  /// minimum.
 		  ///
 		  /// \sa BucketHeap
 		  template <typename IM, bool MIN = true >
 		  class SimpleBucketHeap {
 		  public:
 		    /// Type of the item-int map.
 		    typedef IM ItemIntMap;
 		    /// Type of the priorities.
 		    typedef int 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;
 		  private:
 		    typedef _bucket_heap_bits::DirectionTraits<MIN> Direction;
 		  public:
 		    /// \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.
 		    };
 		  public:
 		    /// \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 SimpleBucketHeap(ItemIntMap &map)
 		      : _iim(map), _free(-1), _num(0), _minimum(0) {}
 		    /// \brief The number of items stored in the heap.
 		    ///
 		    /// This function returns the number of items stored in the heap.
 		    int size() const { return _num; }
 		    /// \brief Check if the heap is empty.
 		    ///
 		    /// This function returns \c true if the heap is empty.
 		    bool empty() const { return _num == 0; }
 		    /// \brief Make the heap empty.
 		    ///
 		    /// 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(); _first.clear(); _free = -1; _num = 0; _minimum = 0;
+		    }
 		    /// \brief Insert a pair of item and priority into the heap.
 		    ///
 		    /// 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) {
 		      push(p.first, p.second);
+		    }
 		    /// \brief Insert an item into the heap with the given priority.
 		    ///
 		    /// 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) {
 		      int idx;
 		      if (_free == -1) {
 		        idx = _data.size();
 		        _data.push_back(BucketItem(i));
 		      } else {
 		        idx = _free;
 		        _free = _data[idx].next;
 		        _data[idx].item = i;
+		      }
 		      _iim[i] = idx;
 		      if (p >= int(_first.size())) _first.resize(p + 1, -1);
 		      _data[idx].next = _first[p];
 		      _first[p] = idx;
 		      if (Direction::less(p, _minimum)) {
 		        _minimum = p;
+		      }
 		      ++_num;
+		    }
 		    /// \brief Return the item having minimum priority.
 		    ///
 		    /// This function returns the item having minimum priority.
 		    /// \pre The heap must be non-empty.
 		    Item top() const {
 		      while (_first[_minimum] == -1) {
 		        Direction::increase(_minimum);
+		      }
 		      return _data[_first[_minimum]].item;
+		    }
 		    /// \brief The minimum priority.
 		    ///
 		    /// This function returns the minimum priority.
 		    /// \pre The heap must be non-empty.
 		    Prio prio() const {
 		      while (_first[_minimum] == -1) {
 		        Direction::increase(_minimum);
+		      }
 		      return _minimum;
+		    }
 		    /// \brief Remove the item having minimum priority.
 		    ///
 		    /// This function removes the item having minimum priority.
 		    /// \pre The heap must be non-empty.
 		    void pop() {
 		      while (_first[_minimum] == -1) {
 		        Direction::increase(_minimum);
+		      }
 		      int idx = _first[_minimum];
 		      _iim[_data[idx].item] = -2;
 		      _first[_minimum] = _data[idx].next;
 		      _data[idx].next = _free;
 		      _free = idx;
 		      --_num;
+		    }
 		    /// \brief The priority of the given item.
 		    ///
 		    /// This function returns the priority of the given item.
 		    /// \param i The item.
 		    /// \pre \e i must be in the heap.
 		    /// \warning This operator is not a constant time function because
 		    /// it scans the whole data structure to find the proper value.
 		    Prio operator[](const Item &i) const {
 		      for (int k = 0; k < int(_first.size()); ++k) {
 		        int idx = _first[k];
 		        while (idx != -1) {
 		          if (_data[idx].item == i) {
 		            return k;
+		          }
 		          idx = _data[idx].next;
+		        }
+		      }
 		      return -1;
+		    }
 		    /// \brief Return the state of an item.
 		    ///
 		    /// 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 idx = _iim[i];
 		      if (idx >= 0) idx = 0;
 		      return State(idx);
+		    }
 		  private:
 		    struct BucketItem {
 		      BucketItem(const Item& _item)
 		        : item(_item) {}
 		      Item item;
 		      int next;
 		    };
 		    ItemIntMap& _iim;
 		    std::vector<int> _first;
 		    std::vector<BucketItem> _data;
 		    int _free, _num;
 		    mutable int _minimum;
 		  }; // class SimpleBucketHeap
+		}
 		#endif

lemon/fib_heap.h

Show inline comments

 		/* -*- mode: C++; indent-tabs-mode: nil; -*-
+		 *
 		 * This file is a part of LEMON, a generic C++ optimization library.
+		 *
 		 * 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_FIB_HEAP_H
 		#define LEMON_FIB_HEAP_H
 		///\file
 		///\ingroup heaps
 		///\brief Fibonacci heap implementation.
 		#include <vector>
 		#include <utility>
 		#include <functional>
 		#include <lemon/math.h>
 		namespace lemon {
 		  /// \ingroup heaps
 		  ///
 		  /// \brief Fibonacci heap data structure.
 		  ///
 		  /// This class implements the \e Fibonacci \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
 		  /// Fibonacci heap. In case of many calls of these operations, it is
 		  /// better to use other heap structure, e.g. \ref BinHeap "binary heap".
 		  ///
 		  /// \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 PR, typename IM, typename CMP>
 		#else
 		  template <typename PR, typename IM, typename CMP = std::less<PR> >
 		#endif
 		  class FibHeap {
 		  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;
 		  private:
 		    class Store;
 		    std::vector<Store> _data;
 		    int _minimum;
 		    ItemIntMap &_iim;
 		    Compare _comp;
 		    int _num;
 		  public:
 		    /// \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.
 		    };
 		    /// \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 FibHeap(ItemIntMap &map)
 		      : _minimum(0), _iim(map), _num() {}
 		    /// \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.
 		    /// \param comp The function object used for comparing the priorities.
 		    FibHeap(ItemIntMap &map, const Compare &comp)
 		      : _minimum(0), _iim(map), _comp(comp), _num() {}
 		    /// \brief The number of items stored in the heap.
 		    ///
 		    /// This function returns the number of items stored in the heap.
 		    int size() const { return _num; }
 		    /// \brief Check if the heap is empty.
 		    ///
 		    /// This function returns \c true if the heap is empty.
 		    bool empty() const { return _num==0; }
 		    /// \brief Make the heap empty.
 		    ///
 		    /// 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(); _minimum = 0; _num = 0;
+		    }
 		    /// \brief Insert an item into the heap with the given priority.
 		    ///
 		    /// This function inserts the given item into the heap with the
 		    /// given priority.
 		    /// \param item The item to insert.
 		    /// \param prio The priority of the item.
 		    /// \pre \e item must not be stored in the heap.
 		    void push (const Item& item, const Prio& prio) {
 		      int i=_iim[item];
 		      if ( i < 0 ) {
 		        int s=_data.size();
 		        _iim.set( item, s );
 		        Store st;
 		        st.name=item;
 		        _data.push_back(st);
 		        i=s;
 		      } else {
 		        _data[i].parent=_data[i].child=-1;
 		        _data[i].degree=0;
 		        _data[i].in=true;
 		        _data[i].marked=false;
+		      }
 		      if ( _num ) {
 		        _data[_data[_minimum].right_neighbor].left_neighbor=i;
 		        _data[i].right_neighbor=_data[_minimum].right_neighbor;
 		        _data[_minimum].right_neighbor=i;
 		        _data[i].left_neighbor=_minimum;
 		        if ( _comp( prio, _data[_minimum].prio) ) _minimum=i;
 		      } else {
 		        _data[i].right_neighbor=_data[i].left_neighbor=i;
 		        _minimum=i;
+		      }
 		      _data[i].prio=prio;
 		      ++_num;
+		    }
 		    /// \brief Return the item having minimum priority.
 		    ///
 		    /// This function returns the item having minimum priority.
 		    /// \pre The heap must be non-empty.
 		    Item top() const { return _data[_minimum].name; }
 		    /// \brief The minimum priority.
 		    ///
 		    /// This function returns the minimum priority.
 		    /// \pre The heap must be non-empty.
 		    Prio prio() const { return _data[_minimum].prio; }
 		    /// \brief Remove the item having minimum priority.
 		    ///
 		    /// This function removes the item having minimum priority.
 		    /// \pre The heap must be non-empty.
 		    void pop() {
 		      /*The first case is that there are only one root.*/
 		      if ( _data[_minimum].left_neighbor==_minimum ) {
 		        _data[_minimum].in=false;
 		        if ( _data[_minimum].degree!=0 ) {
 		          makeRoot(_data[_minimum].child);
 		          _minimum=_data[_minimum].child;
 		          balance();
+		        }
 		      } else {
 		        int right=_data[_minimum].right_neighbor;
 		        unlace(_minimum);
 		        _data[_minimum].in=false;
 		        if ( _data[_minimum].degree > 0 ) {
 		          int left=_data[_minimum].left_neighbor;
 		          int child=_data[_minimum].child;
 		          int last_child=_data[child].left_neighbor;
 		          makeRoot(child);
 		          _data[left].right_neighbor=child;
 		          _data[child].left_neighbor=left;
 		          _data[right].left_neighbor=last_child;
 		          _data[last_child].right_neighbor=right;
+		        }
 		        _minimum=right;
 		        balance();
 		      } // the case where there are more roots
 		      --_num;
+		    }
 		    /// \brief Remove the given item from the heap.
 		    ///
 		    /// 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=_iim[item];
 		      if ( i >= 0 && _data[i].in ) {
 		        if ( _data[i].parent!=-1 ) {
 		          int p=_data[i].parent;
 		          cut(i,p);
 		          cascade(p);
+		        }
 		        _minimum=i;     //As if its prio would be -infinity
 		        pop();
+		      }
+		    }
 		    /// \brief The priority of the given item.
 		    ///
 		    /// This function returns the priority of the given item.
 		    /// \param item The item.
 		    /// \pre \e item must be in the heap.
 		    Prio operator[](const Item& item) const {
 		      return _data[_iim[item]].prio;
+		    }
 		    /// \brief Set the priority of an item or insert it, if it is
 		    /// not stored in the heap.
 		    ///
 		    /// 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 prio The priority.
 		    void set (const Item& item, const Prio& prio) {
 		      int i=_iim[item];
 		      if ( i >= 0 && _data[i].in ) {
 		        if ( _comp(prio, _data[i].prio) ) decrease(item, prio);
 		        if ( _comp(_data[i].prio, prio) ) increase(item, prio);
 		      } else push(item, prio);
+		    }
 		    /// \brief Decrease the priority of an item to the given value.
 		    ///
 		    /// This function decreases the priority of an item to the given value.
 		    /// \param item The item.
 		    /// \param prio The priority.
 		    /// \pre \e item must be stored in the heap with priority at least \e prio.
 		    void decrease (const Item& item, const Prio& prio) {
 		      int i=_iim[item];
 		      _data[i].prio=prio;
 		      int p=_data[i].parent;
 		      if ( p!=-1 && _comp(prio, _data[p].prio) ) {
 		        cut(i,p);
 		        cascade(p);
+		      }
 		      if ( _comp(prio, _data[_minimum].prio) ) _minimum=i;
+		    }
 		    /// \brief Increase the priority of an item to the given value.
 		    ///
 		    /// This function increases the priority of an item to the given value.
 		    /// \param item The item.
 		    /// \param prio The priority.
 		    /// \pre \e item must be stored in the heap with priority at most \e prio.
 		    void increase (const Item& item, const Prio& prio) {
 		      erase(item);
 		      push(item, prio);
+		    }
 		    /// \brief Return the state of an item.
 		    ///
 		    /// 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=_iim[item];
 		      if( i>=0 ) {
 		        if ( _data[i].in ) i=0;
 		        else i=-2;
+		      }
 		      return State(i);
+		    }
 		    /// \brief Set the state of an item in the heap.
 		    ///
 		    /// 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;
+		      }
+		    }
 		  private:
 		    void balance() {
 		      int maxdeg=int( std::floor( 2.08*log(double(_data.size()))))+1;
 		      std::vector<int> A(maxdeg,-1);
 		      /*
 		       *Recall that now minimum does not point to the minimum prio element.
 		       *We set minimum to this during balance().
 		       */
 		      int anchor=_data[_minimum].left_neighbor;
 		      int next=_minimum;
 		      bool end=false;
 		      do {
 		        int active=next;
 		        if ( anchor==active ) end=true;
 		        int d=_data[active].degree;
 		        next=_data[active].right_neighbor;
 		        while (A[d]!=-1) {
 		          if( _comp(_data[active].prio, _data[A[d]].prio) ) {
 		            fuse(active,A[d]);
 		          } else {
 		            fuse(A[d],active);
 		            active=A[d];
+		          }
 		          A[d]=-1;
 		          ++d;
+		        }
 		        A[d]=active;
 		      } while ( !end );
 		      while ( _data[_minimum].parent >=0 )
 		        _minimum=_data[_minimum].parent;
 		      int s=_minimum;
 		      int m=_minimum;
 		      do {
 		        if ( _comp(_data[s].prio, _data[_minimum].prio) ) _minimum=s;
 		        s=_data[s].right_neighbor;
 		      } while ( s != m );
+		    }
 		    void makeRoot(int c) {
 		      int s=c;
 		      do {
 		        _data[s].parent=-1;
 		        s=_data[s].right_neighbor;
 		      } while ( s != c );
+		    }
 		    void cut(int a, int b) {
 		      /*
 		       *Replacing a from the children of b.
 		       */
 		      --_data[b].degree;
 		      if ( _data[b].degree !=0 ) {
 		        int child=_data[b].child;
 		        if ( child==a )
 		          _data[b].child=_data[child].right_neighbor;
 		        unlace(a);
+		      }
 		      /*Lacing a to the roots.*/
 		      int right=_data[_minimum].right_neighbor;
 		      _data[_minimum].right_neighbor=a;
 		      _data[a].left_neighbor=_minimum;
 		      _data[a].right_neighbor=right;
 		      _data[right].left_neighbor=a;
 		      _data[a].parent=-1;
 		      _data[a].marked=false;
+		    }
 		    void cascade(int a) {
 		      if ( _data[a].parent!=-1 ) {
 		        int p=_data[a].parent;
 		        if ( _data[a].marked==false ) _data[a].marked=true;
 		        else {
 		          cut(a,p);
 		          cascade(p);
+		        }
+		      }
+		    }
 		    void fuse(int a, int b) {
 		      unlace(b);
 		      /*Lacing b under a.*/
 		      _data[b].parent=a;
 		      if (_data[a].degree==0) {
 		        _data[b].left_neighbor=b;
 		        _data[b].right_neighbor=b;
 		        _data[a].child=b;
 		      } else {
 		        int child=_data[a].child;
 		        int last_child=_data[child].left_neighbor;
 		        _data[child].left_neighbor=b;
 		        _data[b].right_neighbor=child;
 		        _data[last_child].right_neighbor=b;
 		        _data[b].left_neighbor=last_child;
+		      }
 		      ++_data[a].degree;
 		      _data[b].marked=false;
+		    }
 		    /*
 		     *It is invoked only if a has siblings.
 		     */
 		    void unlace(int a) {
 		      int leftn=_data[a].left_neighbor;
 		      int rightn=_data[a].right_neighbor;
 		      _data[leftn].right_neighbor=rightn;
 		      _data[rightn].left_neighbor=leftn;
+		    }
 		    class Store {
 		      friend class FibHeap;
 		      Item name;
 		      int parent;
 		      int left_neighbor;
 		      int right_neighbor;
 		      int child;
 		      int degree;
 		      bool marked;
 		      bool in;
 		      Prio prio;
 		      Store() : parent(-1), child(-1), degree(), marked(false), in(true) {}
 		    };
 		  };
 		} //namespace lemon
 		#endif //LEMON_FIB_HEAP_H

lemon/fourary_heap.h

Show inline comments

 		/* -*- mode: C++; indent-tabs-mode: nil; -*-
+		 *
 		 * This file is a part of LEMON, a generic C++ optimization library.
+		 *
 		 * 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 heaps
 		///\file
 		///\brief Fourary heap implementation.
 		#include <vector>
 		#include <utility>
 		#include <functional>
 		namespace lemon {
 		  /// \ingroup heaps
 		  ///
 		  ///\brief Fourary heap data structure.
 		  ///
 		  /// This class implements the \e fourary \e heap data structure.
 		  /// It fully conforms to the \ref concepts::Heap "heap concept".
 		  ///
 		  /// 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.
 		  ///
 		  /// \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;
 		    /// \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:
 		    std::vector<Pair> _data;
 		    Compare _comp;
 		    ItemIntMap &_iim;
 		  public:
 		    /// \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 FouraryHeap(ItemIntMap &map) : _iim(map) {}
 		    /// \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.
 		    /// \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.
 		    ///
 		    /// 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(); }
 		    /// \brief Make the heap empty.
 		    ///
 		    /// 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);
+		    }
 		    void bubbleUp(int hole, Pair p) {
 		      int par = parent(hole);
 		      while( hole>0 && less(p,_data[par]) ) {
 		        move(_data[par],hole);
 		        hole = par;
 		        par = parent(hole);
+		      }
 		      move(p, hole);
+		    }
 		    void bubbleDown(int hole, Pair p, int length) {
 		      if( length>1 ) {
 		        int child = firstChild(hole);
 		        while( child+3<length ) {
 		          int min=child;
 		          if( less(_data[++child], _data[min]) ) min=child;
 		          if( less(_data[++child], _data[min]) ) min=child;
 		          if( less(_data[++child], _data[min]) ) min=child;
 		          if( !less(_data[min], p) )
 		            goto ok;
 		          move(_data[min], hole);
 		          hole = min;
 		          child = firstChild(hole);
+		        }
 		        if ( child<length ) {
 		          int min = child;
 		          if( ++child<length && less(_data[child], _data[min]) ) min=child;
 		          if( ++child<length && less(_data[child], _data[min]) ) min=child;
 		          if( less(_data[min], p) ) {
 		            move(_data[min], hole);
 		            hole = min;
+		          }
+		        }
+		      }
 		    ok:
 		      move(p, hole);
+		    }
 		    void move(const Pair &p, int i) {
 		      _data[i] = p;
 		      _iim.set(p.first, i);
+		    }
 		  public:
 		    /// \brief Insert a pair of item and priority into the heap.
 		    ///
 		    /// 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);
 		      bubbleUp(n, p);
+		    }
 		    /// \brief Insert an item into the heap with the given priority.
 		    ///
 		    /// 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 Return the item having minimum priority.
 		    ///
 		    /// This function returns the item having minimum priority.
 		    /// \pre The heap must be non-empty.
 		    Item top() const { return _data[0].first; }
 		    /// \brief The minimum priority.
 		    ///
 		    /// This function returns the minimum priority.
 		    /// \pre The heap must be non-empty.
 		    Prio prio() const { return _data[0].second; }
 		    /// \brief Remove the item having minimum priority.
 		    ///
 		    /// 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) bubbleDown(0, _data[n], n);
 		      _data.pop_back();
+		    }
 		    /// \brief Remove the given item from 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);
 		      if( h<n ) {
 		        if( less(_data[parent(h)], _data[n]) )
 		          bubbleDown(h, _data[n], n);
 		        else
 		          bubbleUp(h, _data[n]);
+		      }
 		      _data.pop_back();
+		    }
 		    /// \brief The priority of the given item.
 		    ///
 		    /// 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;
+		    }
 		    /// \brief Set the priority of an item or insert it, if it is
 		    /// not stored in the heap.
 		    ///
 		    /// 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];
 		      if( idx < 0 )
 		        push(i,p);
 		      else if( _comp(p, _data[idx].second) )
 		        bubbleUp(idx, Pair(i,p));
 		      else
 		        bubbleDown(idx, Pair(i,p), _data.size());
+		    }
 		    /// \brief Decrease the priority of an item to the given value.
 		    ///
 		    /// 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];
 		      bubbleUp(idx, Pair(i,p));
+		    }
 		    /// \brief Increase the priority of an item to the given value.
 		    ///
 		    /// 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];
 		      bubbleDown(idx, Pair(i,p), _data.size());
+		    }
 		    /// \brief Return the state of an item.
 		    ///
 		    /// 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];
 		      if (s>=0) s=0;
 		      return State(s);
+		    }
 		    /// \brief Set the state of an item in the heap.
 		    ///
 		    /// 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;
+		      }
+		    }
 		    /// \brief Replace an item in the heap.
 		    ///
 		    /// 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;
+		    }
 		  }; // class FouraryHeap
 		} // namespace lemon
 		#endif // LEMON_FOURARY_HEAP_H

lemon/kary_heap.h

Show inline comments

 		/* -*- mode: C++; indent-tabs-mode: nil; -*-
+		 *
 		 * This file is a part of LEMON, a generic C++ optimization library.
+		 *
 		 * 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 heaps
 		///\file
 		///\brief Fourary heap implementation.
 		#include <vector>
 		#include <utility>
 		#include <functional>
 		namespace lemon {
 		  /// \ingroup heaps
 		  ///
 		  ///\brief K-ary heap data structure.
 		  ///
 		  /// This class implements the \e K-ary \e heap data structure.
 		  /// It fully conforms to the \ref concepts::Heap "heap concept".
 		  ///
 		  /// 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.
 		  ///
 		  /// \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 K The degree of the heap, each node have at most \e K
 		  /// children. The default is 16. Powers of two are suggested to use
 		  /// so that the multiplications and divisions needed to traverse the
 		  /// nodes of the heap could be performed faster.
 		  /// \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, int K, typename CMP>
 		#else
 		  template <typename PR, typename IM, int K = 16,
 		            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;
 		    /// \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:
 		    std::vector<Pair> _data;
 		    Compare _comp;
 		    ItemIntMap &_iim;
 		  public:
 		    /// \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 KaryHeap(ItemIntMap &map) : _iim(map) {}
 		    /// \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.
 		    /// \param comp The function object used for comparing the priorities.
 		    KaryHeap(ItemIntMap &map, const Compare &comp)
 		      : _iim(map), _comp(comp) {}
 		    /// \brief The number of items stored in the heap.
 		    ///
 		    /// 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(); }
 		    /// \brief Make the heap empty.
 		    ///
 		    /// 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 firstChild(int i) { return K*i+1; }
 		    bool less(const Pair &p1, const Pair &p2) const {
 		      return _comp(p1.second, p2.second);
+		    }
 		    void bubbleUp(int hole, Pair p) {
 		      int par = parent(hole);
 		      while( hole>0 && less(p,_data[par]) ) {
 		        move(_data[par],hole);
 		        hole = par;
 		        par = parent(hole);
+		      }
 		      move(p, hole);
+		    }
 		    void bubbleDown(int hole, Pair p, int length) {
 		      if( length>1 ) {
 		        int child = firstChild(hole);
 		        while( child+K<=length ) {
 		          int min=child;
 		          for (int i=1; i<K; ++i) {
 		            if( less(_data[child+i], _data[min]) )
 		              min=child+i;
+		          }
 		          if( !less(_data[min], p) )
 		            goto ok;
 		          move(_data[min], hole);
 		          hole = min;
 		          child = firstChild(hole);
+		        }
 		        if ( child<length ) {
 		          int min = child;
 		          while (++child < length) {
 		            if( less(_data[child], _data[min]) )
 		              min=child;
+		          }
 		          if( less(_data[min], p) ) {
 		            move(_data[min], hole);
 		            hole = min;
+		          }
+		        }
+		      }
 		    ok:
 		      move(p, hole);
+		    }
 		    void move(const Pair &p, int i) {
 		      _data[i] = p;
 		      _iim.set(p.first, i);
+		    }
 		  public:
 		    /// \brief Insert a pair of item and priority into the heap.
 		    ///
 		    /// 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);
 		      bubbleUp(n, p);
+		    }
 		    /// \brief Insert an item into the heap with the given priority.
 		    ///
 		    /// 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 Return the item having minimum priority.
 		    ///
 		    /// This function returns the item having minimum priority.
 		    /// \pre The heap must be non-empty.
 		    Item top() const { return _data[0].first; }
 		    /// \brief The minimum priority.
 		    ///
 		    /// This function returns the minimum priority.
 		    /// \pre The heap must be non-empty.
 		    Prio prio() const { return _data[0].second; }
 		    /// \brief Remove the item having minimum priority.
 		    ///
 		    /// 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) bubbleDown(0, _data[n], n);
 		      _data.pop_back();
+		    }
 		    /// \brief Remove the given item from 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);
 		      if( h<n ) {
 		        if( less(_data[parent(h)], _data[n]) )
 		          bubbleDown(h, _data[n], n);
 		        else
 		          bubbleUp(h, _data[n]);
+		      }
 		      _data.pop_back();
+		    }
 		    /// \brief The priority of the given item.
 		    ///
 		    /// 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;
+		    }
 		    /// \brief Set the priority of an item or insert it, if it is
 		    /// not stored in the heap.
 		    ///
 		    /// 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];
 		      if( idx<0 )
 		        push(i,p);
 		      else if( _comp(p, _data[idx].second) )
 		        bubbleUp(idx, Pair(i,p));
 		      else
 		        bubbleDown(idx, Pair(i,p), _data.size());
+		    }
 		    /// \brief Decrease the priority of an item to the given value.
 		    ///
 		    /// 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];
 		      bubbleUp(idx, Pair(i,p));
+		    }
 		    /// \brief Increase the priority of an item to the given value.
 		    ///
 		    /// 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];
 		      bubbleDown(idx, Pair(i,p), _data.size());
+		    }
 		    /// \brief Return the state of an item.
 		    ///
 		    /// 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];
 		      if (s>=0) s=0;
 		      return State(s);
+		    }
 		    /// \brief Set the state of an item in the heap.
 		    ///
 		    /// 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;
+		      }
+		    }
 		    /// \brief Replace an item in the heap.
 		    ///
 		    /// 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;
+		    }
 		  }; // class KaryHeap
 		} // namespace lemon
 		#endif // LEMON_KARY_HEAP_H

lemon/pairing_heap.h

Show inline comments

 		/* -*- mode: C++; indent-tabs-mode: nil; -*-
+		 *
 		 * This file is a part of LEMON, a generic C++ optimization library.
+		 *
 		 * 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 heaps
 		///\brief Pairing heap implementation.
 		#include <vector>
 		#include <utility>
 		#include <functional>
 		#include <lemon/math.h>
 		namespace lemon {
 		  /// \ingroup heaps
 		  ///
 		  ///\brief Pairing Heap.
 		  ///
 		  /// 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 of these operations,
 		  /// it is better to use other heap structure, e.g. \ref BinHeap
 		  /// "binary heap".
 		  ///
 		  /// \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 PR, typename IM, typename CMP>
 		#else
 		  template <typename PR, typename IM, typename CMP = std::less<PR> >
 		#endif
 		  class PairingHeap {
 		  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;
 		    /// 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> _data;
 		    int _min;
 		    ItemIntMap &_iim;
 		    Compare _comp;
 		    int _num_items;
 		  public:
 		    /// \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 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.
 		    /// \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.
 		    ///
 		    /// This function returns the number of items stored in the heap.
 		    int size() const { return _num_items; }
 		    /// \brief Check if the heap is empty.
 		    ///
 		    /// This function returns \c true if the heap is empty.
 		    bool empty() const { return _num_items==0; }
 		    /// \brief Make the heap empty.
 		    ///
 		    /// 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();
 		      _min = 0;
 		      _num_items = 0;
+		    }
 		    /// \brief Set the priority of an item or insert it, if it is
 		    /// not stored in the heap.
 		    ///
 		    /// 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=_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 Insert an item into the heap with the given priority.
 		    ///
 		    /// 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=_iim[item];
 		      if( i<0 ) {
 		        int s=_data.size();
 		        _iim.set(item, s);
 		        store st;
 		        st.name=item;
 		        _data.push_back(st);
 		        i=s;
 		      } else {
 		        _data[i].parent=_data[i].child=-1;
 		        _data[i].left_child=false;
 		        _data[i].degree=0;
 		        _data[i].in=true;
+		      }
 		      _data[i].prio=value;
 		      if ( _num_items!=0 ) {
 		        if ( _comp( value, _data[_min].prio) ) {
 		          fuse(i,_min);
 		          _min=i;
+		        }
 		        else fuse(_min,i);
+		      }
 		      else _min=i;
 		      ++_num_items;
+		    }
 		    /// \brief Return the item having minimum priority.
 		    ///
 		    /// This function returns the item having minimum priority.
 		    /// \pre The heap must be non-empty.
 		    Item top() const { return _data[_min].name; }
 		    /// \brief The minimum priority.
 		    ///
 		    /// This function returns the minimum priority.
 		    /// \pre The heap must be non-empty.
 		    const Prio& prio() const { return _data[_min].prio; }
 		    /// \brief The priority of the given item.
 		    ///
 		    /// 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 _data[_iim[item]].prio;
+		    }
 		    /// \brief Remove the item having minimum priority.
 		    ///
 		    /// This function removes the item having minimum priority.
 		    /// \pre The heap must be non-empty.
 		    void pop() {
 		      std::vector<int> trees;
 		      int i=0, child_right = 0;
 		      _data[_min].in=false;
 		      if( -1!=_data[_min].child ) {
 		        i=_data[_min].child;
 		        trees.push_back(i);
 		        _data[i].parent = -1;
 		        _data[_min].child = -1;
 		        int ch=-1;
 		        while( _data[i].child!=-1 ) {
 		          ch=_data[i].child;
 		          if( _data[ch].left_child && i==_data[ch].parent ) {
 		            break;
 		          } else {
 		            if( _data[ch].left_child ) {
 		              child_right=_data[ch].parent;
 		              _data[ch].parent = i;
 		              --_data[i].degree;
+		            }
 		            else {
 		              child_right=ch;
 		              _data[i].child=-1;
 		              _data[i].degree=0;
+		            }
 		            _data[child_right].parent = -1;
 		            trees.push_back(child_right);
 		            i = child_right;
+		          }
+		        }
 		        int num_child = trees.size();
 		        int other;
 		        for( i=0; i<num_child-1; i+=2 ) {
 		          if ( !_comp(_data[trees[i]].prio, _data[trees[i+1]].prio) ) {
 		            other=trees[i];
 		            trees[i]=trees[i+1];
 		            trees[i+1]=other;
+		          }
 		          fuse( trees[i], trees[i+1] );
+		        }
 		        i = (0==(num_child % 2)) ? num_child-2 : num_child-1;
 		        while(i>=2) {
 		          if ( _comp(_data[trees[i]].prio, _data[trees[i-2]].prio) ) {
 		            other=trees[i];
 		            trees[i]=trees[i-2];
 		            trees[i-2]=other;
+		          }
 		          fuse( trees[i-2], trees[i] );
 		          i-=2;
+		        }
 		        _min = trees[0];
+		      }
 		      else {
 		        _min = _data[_min].child;
+		      }
 		      if (_min >= 0) _data[_min].left_child = false;
 		      --_num_items;
+		    }
 		    /// \brief Remove the given item from the heap.
 		    ///
 		    /// 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=_iim[item];
 		      if ( i>=0 && _data[i].in ) {
 		        decrease( item, _data[_min].prio-1 );
 		        pop();
+		      }
+		    }
 		    /// \brief Decrease the priority of an item to the given value.
 		    ///
 		    /// 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=_iim[item];
 		      _data[i].prio=value;
 		      int p=_data[i].parent;
 		      if( _data[i].left_child && i!=_data[p].child ) {
 		        p=_data[p].parent;
+		      }
 		      if ( p!=-1 && _comp(value,_data[p].prio) ) {
 		        cut(i,p);
 		        if ( _comp(_data[_min].prio,value) ) {
 		          fuse(_min,i);
 		        } else {
 		          fuse(i,_min);
 		          _min=i;
+		        }
+		      }
+		    }
 		    /// \brief Increase the priority of an item to the given value.
 		    ///
 		    /// 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 Return the state of an item.
 		    ///
 		    /// 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=_iim[item];
 		      if( i>=0 ) {
 		        if( _data[i].in ) i=0;
 		        else i=-2;
+		      }
 		      return State(i);
+		    }
 		    /// \brief Set the state of an item in the heap.
 		    ///
 		    /// 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;
+		      }
+		    }
 		  private:
 		    void cut(int a, int b) {
 		      int child_a;
 		      switch (_data[a].degree) {
 		        case 2:
 		          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 {
 		            _data[child_a].left_child=false;
 		            _data[child_a].parent=b;
 		            if( a!=_data[b].child )
 		              _data[_data[b].child].parent=child_a;
 		            else
 		              _data[b].child=child_a;
+		          }
 		          --_data[a].degree;
 		          _data[_data[a].child].parent=a;
 		          break;
 		        case 1:
 		          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 {
 		              _data[child_a].left_child=false;
 		              _data[child_a].parent=b;
 		              if( a!=_data[b].child )
 		                _data[_data[b].child].parent=child_a;
 		              else
 		                _data[b].child=child_a;
+		            }
 		            _data[a].child=-1;
+		          }
 		          else {
 		            --_data[b].degree;
 		            if( _data[a].left_child ) {
 		              _data[b].child =
 		                (1==_data[b].degree) ? _data[a].parent : -1;
 		            } else {
 		              if (1==_data[b].degree)
 		                _data[_data[b].child].parent=b;
 		              else
 		                _data[b].child=-1;
+		            }
+		          }
 		          break;
 		        case 0:
 		          --_data[b].degree;
 		          if( _data[a].left_child ) {
 		            _data[b].child =
 		              (0!=_data[b].degree) ? _data[a].parent : -1;
 		          } else {
 		            if( 0!=_data[b].degree )
 		              _data[_data[b].child].parent=b;
 		            else
 		              _data[b].child=-1;
+		          }
 		          break;
+		      }
 		      _data[a].parent=-1;
 		      _data[a].left_child=false;
+		    }
 		    void fuse(int a, int b) {
 		      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 ) {
 		        _data[b].child=child_a;
 		        _data[child_a].parent=b;
 		        _data[child_a].left_child=false;
 		        ++_data[b].degree;
 		        if( -1!=child_b ) {
 		           _data[b].child=child_b;
 		           _data[child_b].parent=child_a;
+		        }
+		      }
 		      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

lemon/radix_heap.h

Show inline comments

 		/* -*- mode: C++; indent-tabs-mode: nil; -*-
+		 *
 		 * This file is a part of LEMON, a generic C++ optimization library.
+		 *
 		 * 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_RADIX_HEAP_H
 		#define LEMON_RADIX_HEAP_H
 		///\ingroup heaps
 		///\file
 		///\brief Radix heap implementation.
 		#include <vector>
 		#include <lemon/error.h>
 		namespace lemon {
 		  /// \ingroup heaps
 		  ///
 		  /// \brief Radix heap data structure.
 		  ///
 		  /// This class implements the \e radix \e heap data structure.
 		  /// It practically conforms to the \ref concepts::Heap "heap concept",
 		  /// but it has some limitations due its special implementation.
 		  /// The type of the priorities must be \c int and the priority of an
 		  /// item cannot be decreased under the priority of the last removed item.
 		  ///
 		  /// \tparam IM A read-writable item map with \c int values, used
 		  /// internally to handle the cross references.
 		  template <typename IM>
 		  class RadixHeap {
 		  public:
 		    /// Type of the item-int map.
 		    typedef IM ItemIntMap;
 		    /// Type of the priorities.
 		    typedef int Prio;
 		    /// Type of the items stored in the heap.
 		    typedef typename ItemIntMap::Key Item;
 		    /// \brief Exception thrown by RadixHeap.
 		    ///
 		    /// This exception is thrown when an item is inserted into a
 		    /// RadixHeap with a priority smaller than the last erased one.
 		    /// \see RadixHeap
 		    class PriorityUnderflowError : public Exception {
 		    public:
 		      virtual const char* what() const throw() {
 		        return "lemon::RadixHeap::PriorityUnderflowError";
+		      }
 		    };
 		    /// \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:
 		    struct RadixItem {
 		      int prev, next, box;
 		      Item item;
 		      int prio;
 		      RadixItem(Item _item, int _prio) : item(_item), prio(_prio) {}
 		    };
 		    struct RadixBox {
 		      int first;
 		      int min, size;
 		      RadixBox(int _min, int _size) : first(-1), min(_min), size(_size) {}
 		    };
 		    std::vector<RadixItem> _data;
 		    std::vector<RadixBox> _boxes;
 		    ItemIntMap &_iim;
 		  public:
 		    /// \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.
 		    /// \param minimum The initial minimum value of the heap.
 		    /// \param capacity The initial capacity of the heap.
 		    RadixHeap(ItemIntMap &map, int minimum = 0, int capacity = 0)
 		      : _iim(map)
+		    {
 		      _boxes.push_back(RadixBox(minimum, 1));
 		      _boxes.push_back(RadixBox(minimum + 1, 1));
 		      while (lower(_boxes.size() - 1, capacity + minimum - 1)) {
 		        extend();
+		      }
+		    }
 		    /// \brief The number of items stored in the heap.
 		    ///
 		    /// 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(); }
 		    /// \brief Make the heap empty.
 		    ///
 		    /// 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.
 		    /// \param minimum The minimum value of the heap.
 		    /// \param capacity The capacity of the heap.
 		    void clear(int minimum = 0, int capacity = 0) {
 		      _data.clear(); _boxes.clear();
 		      _boxes.push_back(RadixBox(minimum, 1));
 		      _boxes.push_back(RadixBox(minimum + 1, 1));
 		      while (lower(_boxes.size() - 1, capacity + minimum - 1)) {
 		        extend();
+		      }
+		    }
 		  private:
 		    bool upper(int box, Prio pr) {
 		      return pr < _boxes[box].min;
+		    }
 		    bool lower(int box, Prio pr) {
 		      return pr >= _boxes[box].min + _boxes[box].size;
+		    }
 		    // Remove item from the box list
 		    void remove(int index) {
 		      if (_data[index].prev >= 0) {
 		        _data[_data[index].prev].next = _data[index].next;
 		      } else {
 		        _boxes[_data[index].box].first = _data[index].next;
+		      }
 		      if (_data[index].next >= 0) {
 		        _data[_data[index].next].prev = _data[index].prev;
+		      }
+		    }
 		    // Insert item into the box list
 		    void insert(int box, int index) {
 		      if (_boxes[box].first == -1) {
 		        _boxes[box].first = index;
 		        _data[index].next = _data[index].prev = -1;
 		      } else {
 		        _data[index].next = _boxes[box].first;
 		        _data[_boxes[box].first].prev = index;
 		        _data[index].prev = -1;
 		        _boxes[box].first = index;
+		      }
 		      _data[index].box = box;
+		    }
 		    // Add a new box to the box list
 		    void extend() {
 		      int min = _boxes.back().min + _boxes.back().size;
 		      int bs = 2 * _boxes.back().size;
 		      _boxes.push_back(RadixBox(min, bs));
+		    }
 		    // Move an item up into the proper box.
 		    void bubbleUp(int index) {
 		      if (!lower(_data[index].box, _data[index].prio)) return;
 		      remove(index);
 		      int box = findUp(_data[index].box, _data[index].prio);
 		      insert(box, index);
+		    }
 		    // Find up the proper box for the item with the given priority
 		    int findUp(int start, int pr) {
 		      while (lower(start, pr)) {
 		        if (++start == int(_boxes.size())) {
 		          extend();
+		        }
+		      }
 		      return start;
+		    }
 		    // Move an item down into the proper box
 		    void bubbleDown(int index) {
 		      if (!upper(_data[index].box, _data[index].prio)) return;
 		      remove(index);
 		      int box = findDown(_data[index].box, _data[index].prio);
 		      insert(box, index);
+		    }
 		    // Find down the proper box for the item with the given priority
 		    int findDown(int start, int pr) {
 		      while (upper(start, pr)) {
 		        if (--start < 0) throw PriorityUnderflowError();
+		      }
 		      return start;
+		    }
 		    // Find the first non-empty box
 		    int findFirst() {
 		      int first = 0;
 		      while (_boxes[first].first == -1) ++first;
 		      return first;
+		    }
 		    // Gives back the minimum priority of the given box
 		    int minValue(int box) {
 		      int min = _data[_boxes[box].first].prio;
 		      for (int k = _boxes[box].first; k != -1; k = _data[k].next) {
 		        if (_data[k].prio < min) min = _data[k].prio;
+		      }
 		      return min;
+		    }
 		    // Rearrange the items of the heap and make the first box non-empty
 		    void moveDown() {
 		      int box = findFirst();
 		      if (box == 0) return;
 		      int min = minValue(box);
 		      for (int i = 0; i <= box; ++i) {
 		        _boxes[i].min = min;
 		        min += _boxes[i].size;
+		      }
 		      int curr = _boxes[box].first, next;
 		      while (curr != -1) {
 		        next = _data[curr].next;
 		        bubbleDown(curr);
 		        curr = next;
+		      }
+		    }
 		    void relocateLast(int index) {
 		      if (index != int(_data.size()) - 1) {
 		        _data[index] = _data.back();
 		        if (_data[index].prev != -1) {
 		          _data[_data[index].prev].next = index;
 		        } else {
 		          _boxes[_data[index].box].first = index;
+		        }
 		        if (_data[index].next != -1) {
 		          _data[_data[index].next].prev = index;
+		        }
 		        _iim[_data[index].item] = index;
+		      }
 		      _data.pop_back();
+		    }
 		  public:
 		    /// \brief Insert an item into the heap with the given priority.
 		    ///
 		    /// 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.
 		    /// \warning This method may throw an \c UnderFlowPriorityException.
 		    void push(const Item &i, const Prio &p) {
 		      int n = _data.size();
 		      _iim.set(i, n);
 		      _data.push_back(RadixItem(i, p));
 		      while (lower(_boxes.size() - 1, p)) {
 		        extend();
+		      }
 		      int box = findDown(_boxes.size() - 1, p);
 		      insert(box, n);
+		    }
 		    /// \brief Return the item having minimum priority.
 		    ///
 		    /// This function returns the item having minimum priority.
 		    /// \pre The heap must be non-empty.
 		    Item top() const {
 		      const_cast<RadixHeap<ItemIntMap>&>(*this).moveDown();
 		      return _data[_boxes[0].first].item;
+		    }
 		    /// \brief The minimum priority.
 		    ///
 		    /// This function returns the minimum priority.
 		    /// \pre The heap must be non-empty.
 		    Prio prio() const {
 		      const_cast<RadixHeap<ItemIntMap>&>(*this).moveDown();
 		      return _data[_boxes[0].first].prio;
+		     }
 		    /// \brief Remove the item having minimum priority.
 		    ///
 		    /// This function removes the item having minimum priority.
 		    /// \pre The heap must be non-empty.
 		    void pop() {
 		      moveDown();
 		      int index = _boxes[0].first;
 		      _iim[_data[index].item] = POST_HEAP;
 		      remove(index);
 		      relocateLast(index);
+		    }
 		    /// \brief Remove the given item from 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 index = _iim[i];
 		      _iim[i] = POST_HEAP;
 		      remove(index);
 		      relocateLast(index);
+		   }
 		    /// \brief The priority of the given item.
 		    ///
 		    /// 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].prio;
+		    }
 		    /// \brief Set the priority of an item or insert it, if it is
 		    /// not stored in the heap.
 		    ///
 		    /// 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.
 		    /// \pre \e i must be in the heap.
 		    /// \warning This method may throw an \c UnderFlowPriorityException.
 		    void set(const Item &i, const Prio &p) {
 		      int idx = _iim[i];
 		      if( idx < 0 ) {
 		        push(i, p);
+		      }
 		      else if( p >= _data[idx].prio ) {
 		        _data[idx].prio = p;
 		        bubbleUp(idx);
 		      } else {
 		        _data[idx].prio = p;
 		        bubbleDown(idx);
+		      }
+		    }
 		    /// \brief Decrease the priority of an item to the given value.
 		    ///
 		    /// 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.
 		    /// \warning This method may throw an \c UnderFlowPriorityException.
 		    void decrease(const Item &i, const Prio &p) {
 		      int idx = _iim[i];
 		      _data[idx].prio = p;
 		      bubbleDown(idx);
+		    }
 		    /// \brief Increase the priority of an item to the given value.
 		    ///
 		    /// 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];
 		      _data[idx].prio = p;
 		      bubbleUp(idx);
+		    }
 		    /// \brief Return the state of an item.
 		    ///
 		    /// 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];
 		      if( s >= 0 ) s = 0;
 		      return State(s);
+		    }
 		    /// \brief Set the state of an item in the heap.
 		    ///
 		    /// 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;
+		      }
+		    }
 		  }; // class RadixHeap
 		} // namespace lemon
 		#endif // LEMON_RADIX_HEAP_H

test/bellman_ford_test.cc

Show inline comments

 		/* -*- mode: C++; indent-tabs-mode: nil; -*-
+		 *
 		 * This file is a part of LEMON, a generic C++ optimization library.
+		 *
 		 * 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.
+		 *
 		 */
 		#include <lemon/concepts/digraph.h>
 		#include <lemon/smart_graph.h>
 		#include <lemon/list_graph.h>
 		#include <lemon/lgf_reader.h>
 		#include <lemon/bellman_ford.h>
 		#include <lemon/path.h>
 		#include "graph_test.h"
 		#include "test_tools.h"
 		using namespace lemon;
 		char test_lgf[] =
 		  "@nodes\n"
 		  "label\n"
 		  "0\n"
 		  "1\n"
 		  "2\n"
 		  "3\n"
 		  "4\n"
 		  "@arcs\n"
 		  "    length\n"
 		  "0 1 3\n"
 		  "1 2 -3\n"
 		  "1 2 -5\n"
 		  "1 3 -2\n"
 		  "0 2 -1\n"
 		  "1 2 -4\n"
 		  "0 3 2\n"
 		  "4 2 -5\n"
 		  "2 3 1\n"
 		  "@attributes\n"
 		  "source 0\n"
 		  "target 3\n";
 		void checkBellmanFordCompile()
+		{
 		  typedef int Value;
 		  typedef concepts::Digraph Digraph;
 		  typedef concepts::ReadMap<Digraph::Arc,Value> LengthMap;
 		  typedef BellmanFord<Digraph, LengthMap> BF;
 		  typedef Digraph::Node Node;
 		  typedef Digraph::Arc Arc;
 		  Digraph gr;
 		  Node s, t, n;
 		  Arc e;
 		  Value l;
 		  int k;
 		  bool b;
 		  BF::DistMap d(gr);
 		  BF::PredMap p(gr);
 		  LengthMap length;
 		  concepts::Path<Digraph> pp;
+		  {
 		    BF bf_test(gr,length);
 		    const BF& const_bf_test = bf_test;
 		    bf_test.run(s);
 		    bf_test.run(s,k);
 		    bf_test.init();
 		    bf_test.addSource(s);
 		    bf_test.addSource(s, 1);
 		    b = bf_test.processNextRound();
 		    b = bf_test.processNextWeakRound();
 		    bf_test.start();
 		    bf_test.checkedStart();
 		    bf_test.limitedStart(k);
 		    l  = const_bf_test.dist(t);
 		    e  = const_bf_test.predArc(t);
 		    s  = const_bf_test.predNode(t);
 		    b  = const_bf_test.reached(t);
 		    d  = const_bf_test.distMap();
 		    p  = const_bf_test.predMap();
 		    pp = const_bf_test.path(t);
 		    for (BF::ActiveIt it(const_bf_test); it != INVALID; ++it) {}
+		  }
+		  {
 		    BF::SetPredMap<concepts::ReadWriteMap<Node,Arc> >
 		      ::SetDistMap<concepts::ReadWriteMap<Node,Value> >
 		      ::SetOperationTraits<BellmanFordDefaultOperationTraits<Value> >
 		      ::Create bf_test(gr,length);
 		    LengthMap length_map;
 		    concepts::ReadWriteMap<Node,Arc> pred_map;
 		    concepts::ReadWriteMap<Node,Value> dist_map;
 		    bf_test
 		      .lengthMap(length_map)
 		      .predMap(pred_map)
 		      .distMap(dist_map);
 		    bf_test.run(s);
 		    bf_test.run(s,k);
 		    bf_test.init();
 		    bf_test.addSource(s);
 		    bf_test.addSource(s, 1);
 		    b = bf_test.processNextRound();
 		    b = bf_test.processNextWeakRound();
 		    bf_test.start();
 		    bf_test.checkedStart();
 		    bf_test.limitedStart(k);
 		    l  = bf_test.dist(t);
 		    e  = bf_test.predArc(t);
 		    s  = bf_test.predNode(t);
 		    b  = bf_test.reached(t);
 		    pp = bf_test.path(t);
+		  }
+		}
 		void checkBellmanFordFunctionCompile()
+		{
 		  typedef int Value;
 		  typedef concepts::Digraph Digraph;
 		  typedef Digraph::Arc Arc;
 		  typedef Digraph::Node Node;
 		  typedef concepts::ReadMap<Digraph::Arc,Value> LengthMap;
 		  Digraph g;
 		  bool b;
 		  bellmanFord(g,LengthMap()).run(Node());
 		  b = bellmanFord(g,LengthMap()).run(Node(),Node());
 		  bellmanFord(g,LengthMap())
 		    .predMap(concepts::ReadWriteMap<Node,Arc>())
 		    .distMap(concepts::ReadWriteMap<Node,Value>())
 		    .run(Node());
 		  b=bellmanFord(g,LengthMap())
 		    .predMap(concepts::ReadWriteMap<Node,Arc>())
 		    .distMap(concepts::ReadWriteMap<Node,Value>())
 		    .path(concepts::Path<Digraph>())
 		    .dist(Value())
 		    .run(Node(),Node());
+		}
 		template <typename Digraph, typename Value>
 		void checkBellmanFord() {
 		  TEMPLATE_DIGRAPH_TYPEDEFS(Digraph);
 		  typedef typename Digraph::template ArcMap<Value> LengthMap;
 		  Digraph gr;
 		  Node s, t;
 		  LengthMap length(gr);
 		  std::istringstream input(test_lgf);
 		  digraphReader(gr, input).
 		    arcMap("length", length).
 		    node("source", s).
 		    node("target", t).
 		    run();
 		  BellmanFord<Digraph, LengthMap>
 		    bf(gr, length);
 		  bf.run(s);
 		  Path<Digraph> p = bf.path(t);
 		  check(bf.reached(t) && bf.dist(t) == -1, "Bellman-Ford found a wrong path.");
 		  check(p.length() == 3, "path() found a wrong path.");
 		  check(checkPath(gr, p), "path() found a wrong path.");
 		  check(pathSource(gr, p) == s, "path() found a wrong path.");
 		  check(pathTarget(gr, p) == t, "path() found a wrong path.");
 		  ListPath<Digraph> path;
 		  Value dist;
 		  bool reached = bellmanFord(gr,length).path(path).dist(dist).run(s,t);
 		  check(reached && dist == -1, "Bellman-Ford found a wrong path.");
 		  check(path.length() == 3, "path() found a wrong path.");
 		  check(checkPath(gr, path), "path() found a wrong path.");
 		  check(pathSource(gr, path) == s, "path() found a wrong path.");
 		  check(pathTarget(gr, path) == t, "path() found a wrong path.");
 		  for(ArcIt e(gr); e!=INVALID; ++e) {
 		    Node u=gr.source(e);
 		    Node v=gr.target(e);
 		    check(!bf.reached(u) || (bf.dist(v) - bf.dist(u) <= length[e]),
 		          "Wrong output. dist(target)-dist(source)-arc_length=" <<
 		          bf.dist(v) - bf.dist(u) - length[e]);
+		  }
 		  for(NodeIt v(gr); v!=INVALID; ++v) {
 		    if (bf.reached(v)) {
 		      check(v==s || bf.predArc(v)!=INVALID, "Wrong tree.");
 		      if (bf.predArc(v)!=INVALID ) {
 		        Arc e=bf.predArc(v);
 		        Node u=gr.source(e);
 		        check(u==bf.predNode(v),"Wrong tree.");
 		        check(bf.dist(v) - bf.dist(u) == length[e],
 		              "Wrong distance! Difference: " <<
 		              bf.dist(v) - bf.dist(u) - length[e]);
+		      }
+		    }
+		  }
+		}
 		void checkBellmanFordNegativeCycle() {
 		  DIGRAPH_TYPEDEFS(SmartDigraph);
 		  SmartDigraph gr;
 		  IntArcMap length(gr);
 		  Node n1 = gr.addNode();
 		  Node n2 = gr.addNode();
 		  Node n3 = gr.addNode();
 		  Node n4 = gr.addNode();
 		  Arc a1 = gr.addArc(n1, n2);
 		  Arc a2 = gr.addArc(n2, n2);
 		  length[a1] = 2;
 		  length[a2] = -1;
+		  {
 		    BellmanFord<SmartDigraph, IntArcMap> bf(gr, length);
 		    bf.run(n1);
 		    StaticPath<SmartDigraph> p = bf.negativeCycle();
 		    check(p.length() == 1 && p.front() == p.back() && p.front() == a2,
 		          "Wrong negative cycle.");
+		  }
 		  length[a2] = 0;
+		  {
 		    BellmanFord<SmartDigraph, IntArcMap> bf(gr, length);
 		    bf.run(n1);
 		    check(bf.negativeCycle().empty(),
 		          "Negative cycle should not be found.");
+		  }
 		  length[gr.addArc(n1, n3)] = 5;
 		  length[gr.addArc(n4, n3)] = 1;
 		  length[gr.addArc(n2, n4)] = 2;
 		  length[gr.addArc(n3, n2)] = -4;
+		  {
 		    BellmanFord<SmartDigraph, IntArcMap> bf(gr, length);
 		    bf.init();
 		    bf.addSource(n1);
 		    for (int i = 0; i < 4; ++i) {
 		      check(bf.negativeCycle().empty(),
 		            "Negative cycle should not be found.");
 		      bf.processNextRound();
+		    }
 		    StaticPath<SmartDigraph> p = bf.negativeCycle();
 		    check(p.length() == 3, "Wrong negative cycle.");
 		    check(length[p.nth(0)] + length[p.nth(1)] + length[p.nth(2)] == -1,
 		          "Wrong negative cycle.");
+		  }
+		}
 		int main() {
 		  checkBellmanFord<ListDigraph, int>();
 		  checkBellmanFord<SmartDigraph, double>();
 		  checkBellmanFordNegativeCycle();
 		  return 0;
+		}

doc/groups.dox

Show inline comments

 		/* -*- mode: C++; indent-tabs-mode: nil; -*-
+		 *
 		 * This file is a part of LEMON, a generic C++ optimization library.
+		 *
 		 * 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.
+		 *
 		 */
 		namespace lemon {
 		/**
 		@defgroup datas Data Structures
 		This group contains the several data structures implemented in LEMON.
 		*/
 		/**
 		@defgroup graphs Graph Structures
 		@ingroup datas
 		\brief Graph structures implemented in LEMON.
 		The implementation of combinatorial algorithms heavily relies on
 		efficient graph implementations. LEMON offers data structures which are
 		planned to be easily used in an experimental phase of implementation studies,
 		and thereafter the program code can be made efficient by small modifications.
 		The most efficient implementation of diverse applications require the
 		usage of different physical graph implementations. These differences
 		appear in the size of graph we require to handle, memory or time usage
 		limitations or in the set of operations through which the graph can be
 		accessed.  LEMON provides several physical graph structures to meet
 		the diverging requirements of the possible users.  In order to save on
 		running time or on memory usage, some structures may fail to provide
 		some graph features like arc/edge or node deletion.
 		Alteration of standard containers need a very limited number of
 		operations, these together satisfy the everyday requirements.
 		In the case of graph structures, different operations are needed which do
 		not alter the physical graph, but gives another view. If some nodes or
 		arcs have to be hidden or the reverse oriented graph have to be used, then
 		this is the case. It also may happen that in a flow implementation
 		the residual graph can be accessed by another algorithm, or a node-set
 		is to be shrunk for another algorithm.
 		LEMON also provides a variety of graphs for these requirements called
 		\ref graph_adaptors "graph adaptors". Adaptors cannot be used alone but only
 		in conjunction with other graph representations.
 		You are free to use the graph structure that fit your requirements
 		the best, most graph algorithms and auxiliary data structures can be used
 		with any graph structure.
 		<b>See also:</b> \ref graph_concepts "Graph Structure Concepts".
 		*/
 		/**
 		@defgroup graph_adaptors Adaptor Classes for Graphs
 		@ingroup graphs
 		\brief Adaptor classes for digraphs and graphs
 		This group contains several useful adaptor classes for digraphs and graphs.
 		The main parts of LEMON are the different graph structures, generic
 		graph algorithms, graph concepts, which couple them, and graph
 		adaptors. While the previous notions are more or less clear, the
 		latter one needs further explanation. Graph adaptors are graph classes
 		which serve for considering graph structures in different ways.
 		A short example makes this much clearer.  Suppose that we have an
 		instance \c g of a directed graph type, say ListDigraph and an algorithm
 		\code
 		template <typename Digraph>
 		int algorithm(const Digraph&);
 		\endcode
 		is needed to run on the reverse oriented graph.  It may be expensive
 		(in time or in memory usage) to copy \c g with the reversed
 		arcs.  In this case, an adaptor class is used, which (according
 		to LEMON \ref concepts::Digraph "digraph concepts") works as a digraph.
 		The adaptor uses the original digraph structure and digraph operations when
 		methods of the reversed oriented graph are called.  This means that the adaptor
 		have minor memory usage, and do not perform sophisticated algorithmic
 		actions.  The purpose of it is to give a tool for the cases when a
 		graph have to be used in a specific alteration.  If this alteration is
 		obtained by a usual construction like filtering the node or the arc set or
 		considering a new orientation, then an adaptor is worthwhile to use.
 		To come back to the reverse oriented graph, in this situation
 		\code
 		template<typename Digraph> class ReverseDigraph;
 		\endcode
 		template class can be used. The code looks as follows
 		\code
 		ListDigraph g;
 		ReverseDigraph<ListDigraph> rg(g);
 		int result = algorithm(rg);
 		\endcode
 		During running the algorithm, the original digraph \c g is untouched.
 		This techniques give rise to an elegant code, and based on stable
 		graph adaptors, complex algorithms can be implemented easily.
 		In flow, circulation and matching problems, the residual
 		graph is of particular importance. Combining an adaptor implementing
 		this with shortest path algorithms or minimum mean cycle algorithms,
 		a range of weighted and cardinality optimization algorithms can be
 		obtained. For other examples, the interested user is referred to the
 		detailed documentation of particular adaptors.
 		The behavior of graph adaptors can be very different. Some of them keep
 		capabilities of the original graph while in other cases this would be
 		meaningless. This means that the concepts that they meet depend
 		on the graph adaptor, and the wrapped graph.
 		For example, if an arc of a reversed digraph is deleted, this is carried
 		out by deleting the corresponding arc of the original digraph, thus the
 		adaptor modifies the original digraph.
 		However in case of a residual digraph, this operation has no sense.
 		Let us stand one more example here to simplify your work.
 		ReverseDigraph has constructor
 		\code
 		ReverseDigraph(Digraph& digraph);
 		\endcode
 		This means that in a situation, when a <tt>const %ListDigraph&</tt>
 		reference to a graph is given, then it have to be instantiated with
 		<tt>Digraph=const %ListDigraph</tt>.
 		\code
 		int algorithm1(const ListDigraph& g) {
 		  ReverseDigraph<const ListDigraph> rg(g);
 		  return algorithm2(rg);
+		}
 		\endcode
 		*/
 		/**
 		@defgroup maps Maps
 		@ingroup datas
 		\brief Map structures implemented in LEMON.
 		This group contains the map structures implemented in LEMON.
 		LEMON provides several special purpose maps and map adaptors that e.g. combine
 		new maps from existing ones.
 		<b>See also:</b> \ref map_concepts "Map Concepts".
 		*/
 		/**
 		@defgroup graph_maps Graph Maps
 		@ingroup maps
 		\brief Special graph-related maps.
 		This group contains maps that are specifically designed to assign
 		values to the nodes and arcs/edges of graphs.
 		If you are looking for the standard graph maps (\c NodeMap, \c ArcMap,
 		\c EdgeMap), see the \ref graph_concepts "Graph Structure Concepts".
 		*/
 		/**
 		\defgroup map_adaptors Map Adaptors
 		\ingroup maps
 		\brief Tools to create new maps from existing ones
 		This group contains map adaptors that are used to create "implicit"
 		maps from other maps.
 		Most of them are \ref concepts::ReadMap "read-only maps".
 		They can make arithmetic and logical operations between one or two maps
 		(negation, shifting, addition, multiplication, logical 'and', 'or',
 		'not' etc.) or e.g. convert a map to another one of different Value type.
 		The typical usage of this classes is passing implicit maps to
 		algorithms.  If a function type algorithm is called then the function
 		type map adaptors can be used comfortable. For example let's see the
 		usage of map adaptors with the \c graphToEps() function.
 		\code
 		  Color nodeColor(int deg) {
 		    if (deg >= 2) {
 		      return Color(0.5, 0.0, 0.5);
 		    } else if (deg == 1) {
 		      return Color(1.0, 0.5, 1.0);
 		    } else {
 		      return Color(0.0, 0.0, 0.0);
+		    }
+		  }
 		  Digraph::NodeMap<int> degree_map(graph);
 		  graphToEps(graph, "graph.eps")
 		    .coords(coords).scaleToA4().undirected()
 		    .nodeColors(composeMap(functorToMap(nodeColor), degree_map))
 		    .run();
 		\endcode
 		The \c functorToMap() function makes an \c int to \c Color map from the
 		\c nodeColor() function. The \c composeMap() compose the \c degree_map
 		and the previously created map. The composed map is a proper function to
 		get the color of each node.
 		The usage with class type algorithms is little bit harder. In this
 		case the function type map adaptors can not be used, because the
 		function map adaptors give back temporary objects.
 		\code
 		  Digraph graph;
 		  typedef Digraph::ArcMap<double> DoubleArcMap;
 		  DoubleArcMap length(graph);
 		  DoubleArcMap speed(graph);
 		  typedef DivMap<DoubleArcMap, DoubleArcMap> TimeMap;
 		  TimeMap time(length, speed);
 		  Dijkstra<Digraph, TimeMap> dijkstra(graph, time);
 		  dijkstra.run(source, target);
 		\endcode
 		We have a length map and a maximum speed map on the arcs of a digraph.
 		The minimum time to pass the arc can be calculated as the division of
 		the two maps which can be done implicitly with the \c DivMap template
 		class. We use the implicit minimum time map as the length map of the
 		\c Dijkstra algorithm.
 		*/
 		/**
 		@defgroup matrices Matrices
 		@ingroup datas
 		\brief Two dimensional data storages implemented in LEMON.
 		This group contains two dimensional data storages implemented in LEMON.
 		*/
 		/**
 		@defgroup paths Path Structures
 		@ingroup datas
 		\brief %Path structures implemented in LEMON.
 		This group contains the path structures implemented in LEMON.
 		LEMON provides flexible data structures to work with paths.
 		All of them have similar interfaces and they can be copied easily with
 		assignment operators and copy constructors. This makes it easy and
 		efficient to have e.g. the Dijkstra algorithm to store its result in
 		any kind of path structure.
-		\sa lemon::concepts::Path
+		\sa \ref concepts::Path "Path concept"
 		*/
 		/**
 		@defgroup heaps Heap Structures
 		@ingroup datas
 		\brief %Heap structures implemented in LEMON.
 		This group contains the heap structures implemented in LEMON.
 		LEMON provides several heap classes. They are efficient implementations
 		of the abstract data type \e priority \e queue. They store items with
 		specified values called \e priorities in such a way that finding and
 		removing the item with minimum priority are efficient.
 		The basic operations are adding and erasing items, changing the priority
 		of an item, etc.
 		Heaps are crucial in several algorithms, such as Dijkstra and Prim.
 		The heap implementations have the same interface, thus any of them can be
 		used easily in such algorithms.
 		\sa \ref concepts::Heap "Heap concept"
 		*/
 		/**
 		@defgroup matrices Matrices
 		@ingroup datas
 		\brief Two dimensional data storages implemented in LEMON.
 		This group contains two dimensional data storages implemented in LEMON.
 		*/
 		/**
 		@defgroup auxdat Auxiliary Data Structures
 		@ingroup datas
 		\brief Auxiliary data structures implemented in LEMON.
 		This group contains some data structures implemented in LEMON in
 		order to make it easier to implement combinatorial algorithms.
 		*/
 		/**
 		@defgroup geomdat Geometric Data Structures
 		@ingroup auxdat
 		\brief Geometric data structures implemented in LEMON.
 		This group contains geometric data structures implemented in LEMON.
 		 - \ref lemon::dim2::Point "dim2::Point" implements a two dimensional
 		   vector with the usual operations.
 		 - \ref lemon::dim2::Box "dim2::Box" can be used to determine the
 		   rectangular bounding box of a set of \ref lemon::dim2::Point
 		   "dim2::Point"'s.
 		*/
 		/**
 		@defgroup matrices Matrices
 		@ingroup auxdat
 		\brief Two dimensional data storages implemented in LEMON.
 		This group contains two dimensional data storages implemented in LEMON.
 		*/
 		/**
 		@defgroup algs Algorithms
 		\brief This group contains the several algorithms
 		implemented in LEMON.
 		This group contains the several algorithms
 		implemented in LEMON.
 		*/
 		/**
 		@defgroup search Graph Search
 		@ingroup algs
 		\brief Common graph search algorithms.
 		This group contains the common graph search algorithms, namely
 		\e breadth-first \e search (BFS) and \e depth-first \e search (DFS).
 		*/
 		/**
 		@defgroup shortest_path Shortest Path Algorithms
 		@ingroup algs
 		\brief Algorithms for finding shortest paths.
 		This group contains the algorithms for finding shortest paths in digraphs.
 		 - \ref Dijkstra algorithm for finding shortest paths from a source node
 		   when all arc lengths are non-negative.
 		 - \ref BellmanFord "Bellman-Ford" algorithm for finding shortest paths
 		   from a source node when arc lenghts can be either positive or negative,
 		   but the digraph should not contain directed cycles with negative total
 		   length.
 		 - \ref FloydWarshall "Floyd-Warshall" and \ref Johnson "Johnson" algorithms
 		   for solving the \e all-pairs \e shortest \e paths \e problem when arc
 		   lenghts can be either positive or negative, but the digraph should
 		   not contain directed cycles with negative total length.
 		 - \ref Suurballe A successive shortest path algorithm for finding
 		   arc-disjoint paths between two nodes having minimum total length.
 		*/
 		/**
 		@defgroup spantree Minimum Spanning Tree Algorithms
 		@ingroup algs
 		\brief Algorithms for finding minimum cost spanning trees and arborescences.
 		This group contains the algorithms for finding minimum cost spanning
 		trees and arborescences.
 		*/
 		/**
 		@defgroup max_flow Maximum Flow Algorithms
 		@ingroup algs
 		\brief Algorithms for finding maximum flows.
 		This group contains the algorithms for finding maximum flows and
 		feasible circulations.
 		The \e maximum \e flow \e problem is to find a flow of maximum value between
 		a single source and a single target. Formally, there is a \f$G=(V,A)\f$
 		digraph, a \f$cap: A\rightarrow\mathbf{R}^+_0\f$ capacity function and
 		\f$s, t \in V\f$ source and target nodes.
 		A maximum flow is an \f$f: A\rightarrow\mathbf{R}^+_0\f$ solution of the
 		following optimization problem.
 		\f[ \max\sum_{sv\in A} f(sv) - \sum_{vs\in A} f(vs) \f]
 		\f[ \sum_{uv\in A} f(uv) = \sum_{vu\in A} f(vu)
 		    \quad \forall u\in V\setminus\{s,t\} \f]
 		\f[ 0 \leq f(uv) \leq cap(uv) \quad \forall uv\in A \f]
 		LEMON contains several algorithms for solving maximum flow problems:
 		- \ref EdmondsKarp Edmonds-Karp algorithm.
 		- \ref Preflow Goldberg-Tarjan's preflow push-relabel algorithm.
 		- \ref DinitzSleatorTarjan Dinitz's blocking flow algorithm with dynamic trees.
 		- \ref GoldbergTarjan Preflow push-relabel algorithm with dynamic trees.
 		In most cases the \ref Preflow "Preflow" algorithm provides the
 		fastest method for computing a maximum flow. All implementations
 		also provide functions to query the minimum cut, which is the dual
 		problem of maximum flow.
 		\ref Circulation is a preflow push-relabel algorithm implemented directly
 		for finding feasible circulations, which is a somewhat different problem,
 		but it is strongly related to maximum flow.
 		For more information, see \ref Circulation.
 		*/
 		/**
 		@defgroup min_cost_flow_algs Minimum Cost Flow Algorithms
 		@ingroup algs
 		\brief Algorithms for finding minimum cost flows and circulations.
 		This group contains the algorithms for finding minimum cost flows and
 		circulations. For more information about this problem and its dual
 		solution see \ref min_cost_flow "Minimum Cost Flow Problem".
 		LEMON contains several algorithms for this problem.
 		 - \ref NetworkSimplex Primal Network Simplex algorithm with various
 		   pivot strategies.
 		 - \ref CostScaling Push-Relabel and Augment-Relabel algorithms based on
 		   cost scaling.
 		 - \ref CapacityScaling Successive Shortest %Path algorithm with optional
 		   capacity scaling.
 		 - \ref CancelAndTighten The Cancel and Tighten algorithm.
 		 - \ref CycleCanceling Cycle-Canceling algorithms.
 		In general NetworkSimplex is the most efficient implementation,
 		but in special cases other algorithms could be faster.
 		For example, if the total supply and/or capacities are rather small,
 		CapacityScaling is usually the fastest algorithm (without effective scaling).
 		*/
 		/**
 		@defgroup min_cut Minimum Cut Algorithms
 		@ingroup algs
 		\brief Algorithms for finding minimum cut in graphs.
 		This group contains the algorithms for finding minimum cut in graphs.
 		The \e minimum \e cut \e problem is to find a non-empty and non-complete
 		\f$X\f$ subset of the nodes with minimum overall capacity on
 		outgoing arcs. Formally, there is a \f$G=(V,A)\f$ digraph, a
 		\f$cap: A\rightarrow\mathbf{R}^+_0\f$ capacity function. The minimum
 		cut is the \f$X\f$ solution of the next optimization problem:
 		\f[ \min_{X \subset V, X\not\in \{\emptyset, V\}}
-		    \sum_{uv\in A, u\in X, v\not\in X}cap(uv) \f]
+		    \sum_{uv\in A: u\in X, v\not\in X}cap(uv) \f]
 		LEMON contains several algorithms related to minimum cut problems:
 		- \ref HaoOrlin "Hao-Orlin algorithm" for calculating minimum cut
 		  in directed graphs.
 		- \ref NagamochiIbaraki "Nagamochi-Ibaraki algorithm" for
 		  calculating minimum cut in undirected graphs.
 		- \ref GomoryHu "Gomory-Hu tree computation" for calculating
 		  all-pairs minimum cut in undirected graphs.
 		If you want to find minimum cut just between two distinict nodes,
 		see the \ref max_flow "maximum flow problem".
 		*/
 		/**
 		@defgroup graph_properties Connectivity and Other Graph Properties
 		@ingroup algs
 		\brief Algorithms for discovering the graph properties
 		This group contains the algorithms for discovering the graph properties
 		like connectivity, bipartiteness, euler property, simplicity etc.
 		\image html edge_biconnected_components.png
 		\image latex edge_biconnected_components.eps "bi-edge-connected components" width=\textwidth
 		*/
 		/**
 		@defgroup planar Planarity Embedding and Drawing
 		@ingroup algs
 		\brief Algorithms for planarity checking, embedding and drawing
 		This group contains the algorithms for planarity checking,
 		embedding and drawing.
 		\image html planar.png
 		\image latex planar.eps "Plane graph" width=\textwidth
 		*/
 		/**
 		@defgroup matching Matching Algorithms
 		@ingroup algs
 		\brief Algorithms for finding matchings in graphs and bipartite graphs.
 		This group contains the algorithms for calculating
 		matchings in graphs and bipartite graphs. The general matching problem is
 		finding a subset of the edges for which each node has at most one incident
 		edge.
 		There are several different algorithms for calculate matchings in
 		graphs.  The matching problems in bipartite graphs are generally
 		easier than in general graphs. The goal of the matching optimization
 		can be finding maximum cardinality, maximum weight or minimum cost
 		matching. The search can be constrained to find perfect or
 		maximum cardinality matching.
 		The matching algorithms implemented in LEMON:
 		- \ref MaxBipartiteMatching Hopcroft-Karp augmenting path algorithm
 		  for calculating maximum cardinality matching in bipartite graphs.
 		- \ref PrBipartiteMatching Push-relabel algorithm
 		  for calculating maximum cardinality matching in bipartite graphs.
 		- \ref MaxWeightedBipartiteMatching
 		  Successive shortest path algorithm for calculating maximum weighted
 		  matching and maximum weighted bipartite matching in bipartite graphs.
 		- \ref MinCostMaxBipartiteMatching
 		  Successive shortest path algorithm for calculating minimum cost maximum
 		  matching in bipartite graphs.
 		- \ref MaxMatching Edmond's blossom shrinking algorithm for calculating
 		  maximum cardinality matching in general graphs.
 		- \ref MaxWeightedMatching Edmond's blossom shrinking algorithm for calculating
 		  maximum weighted matching in general graphs.
 		- \ref MaxWeightedPerfectMatching
 		  Edmond's blossom shrinking algorithm for calculating maximum weighted
 		  perfect matching in general graphs.
 		\image html bipartite_matching.png
 		\image latex bipartite_matching.eps "Bipartite Matching" width=\textwidth
 		*/
 		/**
-		@defgroup spantree Minimum Spanning Tree Algorithms
+		@defgroup graph_properties Connectivity and Other Graph Properties
 		@ingroup algs
-		\brief Algorithms for finding minimum cost spanning trees and arborescences.
+		\brief Algorithms for discovering the graph properties
 		This group contains the algorithms for finding minimum cost spanning
 		trees and arborescences.
 		This group contains the algorithms for discovering the graph properties
 		like connectivity, bipartiteness, euler property, simplicity etc.
 		\image html connected_components.png
 		\image latex connected_components.eps "Connected components" width=\textwidth
 		*/
 		/**
 		@defgroup planar Planarity Embedding and Drawing
 		@ingroup algs
 		\brief Algorithms for planarity checking, embedding and drawing
 		This group contains the algorithms for planarity checking,
 		embedding and drawing.
 		\image html planar.png
 		\image latex planar.eps "Plane graph" width=\textwidth
 		*/
 		/**
 		@defgroup approx Approximation Algorithms
 		@ingroup algs
 		\brief Approximation algorithms.
 		This group contains the approximation and heuristic algorithms
 		implemented in LEMON.
 		*/
 		/**
 		@defgroup auxalg Auxiliary Algorithms
 		@ingroup algs
 		\brief Auxiliary algorithms implemented in LEMON.
 		This group contains some algorithms implemented in LEMON
 		in order to make it easier to implement complex algorithms.
 		*/
 		/**
 		@defgroup approx Approximation Algorithms
 		@ingroup algs
 		\brief Approximation algorithms.
 		This group contains the approximation and heuristic algorithms
 		implemented in LEMON.
 		*/
 		/**
 		@defgroup gen_opt_group General Optimization Tools
 		\brief This group contains some general optimization frameworks
 		implemented in LEMON.
 		This group contains some general optimization frameworks
 		implemented in LEMON.
 		*/
 		/**
 		@defgroup lp_group Lp and Mip Solvers
 		@ingroup gen_opt_group
 		\brief Lp and Mip solver interfaces for LEMON.
 		This group contains Lp and Mip solver interfaces for LEMON. The
 		various LP solvers could be used in the same manner with this
 		interface.
 		*/
 		/**
 		@defgroup lp_utils Tools for Lp and Mip Solvers
 		@ingroup lp_group
 		\brief Helper tools to the Lp and Mip solvers.
 		This group adds some helper tools to general optimization framework
 		implemented in LEMON.
 		*/
 		/**
 		@defgroup metah Metaheuristics
 		@ingroup gen_opt_group
 		\brief Metaheuristics for LEMON library.
 		This group contains some metaheuristic optimization tools.
 		*/
 		/**
 		@defgroup utils Tools and Utilities
 		\brief Tools and utilities for programming in LEMON
 		Tools and utilities for programming in LEMON.
 		*/
 		/**
 		@defgroup gutils Basic Graph Utilities
 		@ingroup utils
 		\brief Simple basic graph utilities.
 		This group contains some simple basic graph utilities.
 		*/
 		/**
 		@defgroup misc Miscellaneous Tools
 		@ingroup utils
 		\brief Tools for development, debugging and testing.
 		This group contains several useful tools for development,
 		debugging and testing.
 		*/
 		/**
 		@defgroup timecount Time Measuring and Counting
 		@ingroup misc
 		\brief Simple tools for measuring the performance of algorithms.
 		This group contains simple tools for measuring the performance
 		of algorithms.
 		*/
 		/**
 		@defgroup exceptions Exceptions
 		@ingroup utils
 		\brief Exceptions defined in LEMON.
 		This group contains the exceptions defined in LEMON.
 		*/
 		/**
 		@defgroup io_group Input-Output
 		\brief Graph Input-Output methods
 		This group contains the tools for importing and exporting graphs
 		and graph related data. Now it supports the \ref lgf-format
 		"LEMON Graph Format", the \c DIMACS format and the encapsulated
 		postscript (EPS) format.
 		*/
 		/**
 		@defgroup lemon_io LEMON Graph Format
 		@ingroup io_group
 		\brief Reading and writing LEMON Graph Format.
 		This group contains methods for reading and writing
 		\ref lgf-format "LEMON Graph Format".
 		*/
 		/**
 		@defgroup eps_io Postscript Exporting
 		@ingroup io_group
 		\brief General \c EPS drawer and graph exporter
 		This group contains general \c EPS drawing methods and special
 		graph exporting tools.
 		*/
 		/**
-		@defgroup dimacs_group DIMACS format
+		@defgroup dimacs_group DIMACS Format
 		@ingroup io_group
 		\brief Read and write files in DIMACS format
 		Tools to read a digraph from or write it to a file in DIMACS format data.
 		*/
 		/**
 		@defgroup nauty_group NAUTY Format
 		@ingroup io_group
 		\brief Read \e Nauty format
 		Tool to read graphs from \e Nauty format data.
 		*/
 		/**
 		@defgroup concept Concepts
 		\brief Skeleton classes and concept checking classes
 		This group contains the data/algorithm skeletons and concept checking
 		classes implemented in LEMON.
 		The purpose of the classes in this group is fourfold.
 		- These classes contain the documentations of the %concepts. In order
 		  to avoid document multiplications, an implementation of a concept
 		  simply refers to the corresponding concept class.
 		- These classes declare every functions, <tt>typedef</tt>s etc. an
 		  implementation of the %concepts should provide, however completely
 		  without implementations and real data structures behind the
 		  interface. On the other hand they should provide nothing else. All
 		  the algorithms working on a data structure meeting a certain concept
 		  should compile with these classes. (Though it will not run properly,
 		  of course.) In this way it is easily to check if an algorithm
 		  doesn't use any extra feature of a certain implementation.
 		- The concept descriptor classes also provide a <em>checker class</em>
 		  that makes it possible to check whether a certain implementation of a
 		  concept indeed provides all the required features.
 		- Finally, They can serve as a skeleton of a new implementation of a concept.
 		*/
 		/**
 		@defgroup graph_concepts Graph Structure Concepts
 		@ingroup concept
 		\brief Skeleton and concept checking classes for graph structures
 		This group contains the skeletons and concept checking classes of LEMON's
 		graph structures and helper classes used to implement these.
 		*/
 		/**
 		@defgroup map_concepts Map Concepts
 		@ingroup concept
 		\brief Skeleton and concept checking classes for maps
 		This group contains the skeletons and concept checking classes of maps.
 		*/
 		/**
 		@defgroup tools Standalone Utility Applications
 		Some utility applications are listed here.
 		The standard compilation procedure (<tt>./configure;make</tt>) will compile
 		them, as well.
 		*/
 		/**
 		\anchor demoprograms
 		@defgroup demos Demo Programs
 		Some demo programs are listed here. Their full source codes can be found in
 		the \c demo subdirectory of the source tree.
 		In order to compile them, use the <tt>make demo</tt> or the
 		<tt>make check</tt> commands.
 		*/
 		/**
 		@defgroup tools Standalone Utility Applications
 		Some utility applications are listed here.
 		The standard compilation procedure (<tt>./configure;make</tt>) will compile
 		them, as well.
 		*/
+		}

lemon/Makefile.am

Show inline comments

 		EXTRA_DIST += \
 			lemon/lemon.pc.in \
 			lemon/CMakeLists.txt \
 			lemon/config.h.cmake
 		pkgconfig_DATA += lemon/lemon.pc
 		lib_LTLIBRARIES += lemon/libemon.la
 		lemon_libemon_la_SOURCES = \
 			lemon/arg_parser.cc \
 			lemon/base.cc \
 			lemon/color.cc \
 			lemon/lp_base.cc \
 			lemon/lp_skeleton.cc \
 			lemon/random.cc \
 			lemon/bits/windows.cc
 		nodist_lemon_HEADERS = lemon/config.h
 		lemon_libemon_la_CXXFLAGS = \
 			$(AM_CXXFLAGS) \
 			$(GLPK_CFLAGS) \
 			$(CPLEX_CFLAGS) \
 			$(SOPLEX_CXXFLAGS) \
 			$(CLP_CXXFLAGS) \
 			$(CBC_CXXFLAGS)
 		lemon_libemon_la_LDFLAGS = \
 			$(GLPK_LIBS) \
 			$(CPLEX_LIBS) \
 			$(SOPLEX_LIBS) \
 			$(CLP_LIBS) \
 			$(CBC_LIBS)
 		if HAVE_GLPK
 		lemon_libemon_la_SOURCES += lemon/glpk.cc
 		endif
 		if HAVE_CPLEX
 		lemon_libemon_la_SOURCES += lemon/cplex.cc
 		endif
 		if HAVE_SOPLEX
 		lemon_libemon_la_SOURCES += lemon/soplex.cc
 		endif
 		if HAVE_CLP
 		lemon_libemon_la_SOURCES += lemon/clp.cc
 		endif
 		if HAVE_CBC
 		lemon_libemon_la_SOURCES += lemon/cbc.cc
 		endif
 		lemon_HEADERS += \
 			lemon/adaptors.h \
 			lemon/arg_parser.h \
 			lemon/assert.h \
 			lemon/bellman_ford.h \
 			lemon/bfs.h \
 			lemon/bin_heap.h \
 			lemon/binom_heap.h \
 			lemon/bucket_heap.h \
 			lemon/cbc.h \
 			lemon/circulation.h \
 			lemon/clp.h \
 			lemon/color.h \
 			lemon/concept_check.h \
 			lemon/connectivity.h \
 			lemon/counter.h \
 			lemon/core.h \
 			lemon/cplex.h \
 			lemon/dfs.h \
 			lemon/dijkstra.h \
 			lemon/dim2.h \
 			lemon/dimacs.h \
 			lemon/edge_set.h \
 			lemon/elevator.h \
 			lemon/error.h \
 			lemon/euler.h \
 			lemon/fib_heap.h \
 			lemon/fourary_heap.h \
 			lemon/full_graph.h \
 			lemon/glpk.h \
 			lemon/gomory_hu.h \
 			lemon/graph_to_eps.h \
 			lemon/grid_graph.h \
 			lemon/hypercube_graph.h \
 			lemon/kary_heap.h \
 			lemon/kruskal.h \
 			lemon/hao_orlin.h \
 			lemon/lgf_reader.h \
 			lemon/lgf_writer.h \
 			lemon/list_graph.h \
 			lemon/lp.h \
 			lemon/lp_base.h \
 			lemon/lp_skeleton.h \
 			lemon/list_graph.h \
 			lemon/maps.h \
 			lemon/matching.h \
 			lemon/math.h \
 			lemon/min_cost_arborescence.h \
 			lemon/nauty_reader.h \
 			lemon/network_simplex.h \
 			lemon/pairing_heap.h \
 			lemon/path.h \
 			lemon/preflow.h \
 			lemon/radix_heap.h \
 			lemon/radix_sort.h \
 			lemon/random.h \
 			lemon/smart_graph.h \
 			lemon/soplex.h \
 			lemon/suurballe.h \
 			lemon/time_measure.h \
 			lemon/tolerance.h \
 			lemon/unionfind.h \
 			lemon/bits/windows.h
 		bits_HEADERS += \
 			lemon/bits/alteration_notifier.h \
 			lemon/bits/array_map.h \
 			lemon/bits/bezier.h \
 			lemon/bits/default_map.h \
 			lemon/bits/edge_set_extender.h \
 			lemon/bits/enable_if.h \
 			lemon/bits/graph_adaptor_extender.h \
 			lemon/bits/graph_extender.h \
 			lemon/bits/map_extender.h \
 			lemon/bits/path_dump.h \
 			lemon/bits/solver_bits.h \
 			lemon/bits/traits.h \
 			lemon/bits/variant.h \
 			lemon/bits/vector_map.h
 		concept_HEADERS += \
 			lemon/concepts/digraph.h \
 			lemon/concepts/graph.h \
 			lemon/concepts/graph_components.h \
 			lemon/concepts/heap.h \
 			lemon/concepts/maps.h \
 			lemon/concepts/path.h

lemon/bfs.h

Show inline comments

@@ -161,514 +161,514 @@
 		    //Pointer to the map of predecessor arcs.
 		    PredMap *_pred;
 		    //Indicates if _pred is locally allocated (true) or not.
 		    bool local_pred;
 		    //Pointer to the map of distances.
 		    DistMap *_dist;
 		    //Indicates if _dist is locally allocated (true) or not.
 		    bool local_dist;
 		    //Pointer to the map of reached status of the nodes.
 		    ReachedMap *_reached;
 		    //Indicates if _reached is locally allocated (true) or not.
 		    bool local_reached;
 		    //Pointer to the map of processed status of the nodes.
 		    ProcessedMap *_processed;
 		    //Indicates if _processed is locally allocated (true) or not.
 		    bool local_processed;
 		    std::vector<typename Digraph::Node> _queue;
 		    int _queue_head,_queue_tail,_queue_next_dist;
 		    int _curr_dist;
 		    //Creates the maps if necessary.
 		    void create_maps()
+		    {
 		      if(!_pred) {
 		        local_pred = true;
 		        _pred = Traits::createPredMap(*G);
+		      }
 		      if(!_dist) {
 		        local_dist = true;
 		        _dist = Traits::createDistMap(*G);
+		      }
 		      if(!_reached) {
 		        local_reached = true;
 		        _reached = Traits::createReachedMap(*G);
+		      }
 		      if(!_processed) {
 		        local_processed = true;
 		        _processed = Traits::createProcessedMap(*G);
+		      }
+		    }
 		  protected:
 		    Bfs() {}
 		  public:
 		    typedef Bfs Create;
 		    ///\name Named Template Parameters
 		    ///@{
 		    template <class T>
 		    struct SetPredMapTraits : public Traits {
 		      typedef T PredMap;
 		      static PredMap *createPredMap(const Digraph &)
+		      {
 		        LEMON_ASSERT(false, "PredMap is not initialized");
 		        return 0; // ignore warnings
+		      }
 		    };
 		    ///\brief \ref named-templ-param "Named parameter" for setting
 		    ///\c PredMap type.
 		    ///
 		    ///\ref named-templ-param "Named parameter" for setting
 		    ///\c PredMap type.
 		    ///It must conform to the \ref concepts::WriteMap "WriteMap" concept.
 		    template <class T>
 		    struct SetPredMap : public Bfs< Digraph, SetPredMapTraits<T> > {
 		      typedef Bfs< Digraph, SetPredMapTraits<T> > Create;
 		    };
 		    template <class T>
 		    struct SetDistMapTraits : public Traits {
 		      typedef T DistMap;
 		      static DistMap *createDistMap(const Digraph &)
+		      {
 		        LEMON_ASSERT(false, "DistMap is not initialized");
 		        return 0; // ignore warnings
+		      }
 		    };
 		    ///\brief \ref named-templ-param "Named parameter" for setting
 		    ///\c DistMap type.
 		    ///
 		    ///\ref named-templ-param "Named parameter" for setting
 		    ///\c DistMap type.
 		    ///It must conform to the \ref concepts::WriteMap "WriteMap" concept.
 		    template <class T>
 		    struct SetDistMap : public Bfs< Digraph, SetDistMapTraits<T> > {
 		      typedef Bfs< Digraph, SetDistMapTraits<T> > Create;
 		    };
 		    template <class T>
 		    struct SetReachedMapTraits : public Traits {
 		      typedef T ReachedMap;
 		      static ReachedMap *createReachedMap(const Digraph &)
+		      {
 		        LEMON_ASSERT(false, "ReachedMap is not initialized");
 		        return 0; // ignore warnings
+		      }
 		    };
 		    ///\brief \ref named-templ-param "Named parameter" for setting
 		    ///\c ReachedMap type.
 		    ///
 		    ///\ref named-templ-param "Named parameter" for setting
 		    ///\c ReachedMap type.
 		    ///It must conform to the \ref concepts::ReadWriteMap "ReadWriteMap" concept.
 		    template <class T>
 		    struct SetReachedMap : public Bfs< Digraph, SetReachedMapTraits<T> > {
 		      typedef Bfs< Digraph, SetReachedMapTraits<T> > Create;
 		    };
 		    template <class T>
 		    struct SetProcessedMapTraits : public Traits {
 		      typedef T ProcessedMap;
 		      static ProcessedMap *createProcessedMap(const Digraph &)
+		      {
 		        LEMON_ASSERT(false, "ProcessedMap is not initialized");
 		        return 0; // ignore warnings
+		      }
 		    };
 		    ///\brief \ref named-templ-param "Named parameter" for setting
 		    ///\c ProcessedMap type.
 		    ///
 		    ///\ref named-templ-param "Named parameter" for setting
 		    ///\c ProcessedMap type.
 		    ///It must conform to the \ref concepts::WriteMap "WriteMap" concept.
 		    template <class T>
 		    struct SetProcessedMap : public Bfs< Digraph, SetProcessedMapTraits<T> > {
 		      typedef Bfs< Digraph, SetProcessedMapTraits<T> > Create;
 		    };
 		    struct SetStandardProcessedMapTraits : public Traits {
 		      typedef typename Digraph::template NodeMap<bool> ProcessedMap;
 		      static ProcessedMap *createProcessedMap(const Digraph &g)
+		      {
 		        return new ProcessedMap(g);
 		        return 0; // ignore warnings
+		      }
 		    };
 		    ///\brief \ref named-templ-param "Named parameter" for setting
 		    ///\c ProcessedMap type to be <tt>Digraph::NodeMap<bool></tt>.
 		    ///
 		    ///\ref named-templ-param "Named parameter" for setting
 		    ///\c ProcessedMap type to be <tt>Digraph::NodeMap<bool></tt>.
 		    ///If you don't set it explicitly, it will be automatically allocated.
 		    struct SetStandardProcessedMap :
 		      public Bfs< Digraph, SetStandardProcessedMapTraits > {
 		      typedef Bfs< Digraph, SetStandardProcessedMapTraits > Create;
 		    };
 		    ///@}
 		  public:
 		    ///Constructor.
 		    ///Constructor.
 		    ///\param g The digraph the algorithm runs on.
 		    Bfs(const Digraph &g) :
 		      G(&g),
 		      _pred(NULL), local_pred(false),
 		      _dist(NULL), local_dist(false),
 		      _reached(NULL), local_reached(false),
 		      _processed(NULL), local_processed(false)
 		    { }
 		    ///Destructor.
 		    ~Bfs()
+		    {
 		      if(local_pred) delete _pred;
 		      if(local_dist) delete _dist;
 		      if(local_reached) delete _reached;
 		      if(local_processed) delete _processed;
+		    }
 		    ///Sets the map that stores the predecessor arcs.
 		    ///Sets the map that stores the predecessor arcs.
 		    ///If you don't use this function before calling \ref run(Node) "run()"
 		    ///or \ref init(), an instance will be allocated automatically.
 		    ///The destructor deallocates this automatically allocated map,
 		    ///of course.
 		    ///\return <tt> (*this) </tt>
 		    Bfs &predMap(PredMap &m)
+		    {
 		      if(local_pred) {
 		        delete _pred;
 		        local_pred=false;
+		      }
 		      _pred = &m;
 		      return *this;
+		    }
 		    ///Sets the map that indicates which nodes are reached.
 		    ///Sets the map that indicates which nodes are reached.
 		    ///If you don't use this function before calling \ref run(Node) "run()"
 		    ///or \ref init(), an instance will be allocated automatically.
 		    ///The destructor deallocates this automatically allocated map,
 		    ///of course.
 		    ///\return <tt> (*this) </tt>
 		    Bfs &reachedMap(ReachedMap &m)
+		    {
 		      if(local_reached) {
 		        delete _reached;
 		        local_reached=false;
+		      }
 		      _reached = &m;
 		      return *this;
+		    }
 		    ///Sets the map that indicates which nodes are processed.
 		    ///Sets the map that indicates which nodes are processed.
 		    ///If you don't use this function before calling \ref run(Node) "run()"
 		    ///or \ref init(), an instance will be allocated automatically.
 		    ///The destructor deallocates this automatically allocated map,
 		    ///of course.
 		    ///\return <tt> (*this) </tt>
 		    Bfs &processedMap(ProcessedMap &m)
+		    {
 		      if(local_processed) {
 		        delete _processed;
 		        local_processed=false;
+		      }
 		      _processed = &m;
 		      return *this;
+		    }
 		    ///Sets the map that stores the distances of the nodes.
 		    ///Sets the map that stores the distances of the nodes calculated by
 		    ///the algorithm.
 		    ///If you don't use this function before calling \ref run(Node) "run()"
 		    ///or \ref init(), an instance will be allocated automatically.
 		    ///The destructor deallocates this automatically allocated map,
 		    ///of course.
 		    ///\return <tt> (*this) </tt>
 		    Bfs &distMap(DistMap &m)
+		    {
 		      if(local_dist) {
 		        delete _dist;
 		        local_dist=false;
+		      }
 		      _dist = &m;
 		      return *this;
+		    }
 		  public:
 		    ///\name Execution Control
 		    ///The simplest way to execute the BFS algorithm is to use one of the
 		    ///member functions called \ref run(Node) "run()".\n
 		    ///If you need more control on the execution, first you have to call
 		    ///\ref init(), then you can add several source nodes with
 		    ///If you need better control on the execution, you have to call
 		    ///\ref init() first, then you can add several source nodes with
 		    ///\ref addSource(). Finally the actual path computation can be
 		    ///performed with one of the \ref start() functions.
 		    ///@{
 		    ///\brief Initializes the internal data structures.
 		    ///
 		    ///Initializes the internal data structures.
 		    void init()
+		    {
 		      create_maps();
 		      _queue.resize(countNodes(*G));
 		      _queue_head=_queue_tail=0;
 		      _curr_dist=1;
 		      for ( NodeIt u(*G) ; u!=INVALID ; ++u ) {
 		        _pred->set(u,INVALID);
 		        _reached->set(u,false);
 		        _processed->set(u,false);
+		      }
+		    }
 		    ///Adds a new source node.
 		    ///Adds a new source node to the set of nodes to be processed.
 		    ///
 		    void addSource(Node s)
+		    {
 		      if(!(*_reached)[s])
+		        {
 		          _reached->set(s,true);
 		          _pred->set(s,INVALID);
 		          _dist->set(s,0);
 		          _queue[_queue_head++]=s;
 		          _queue_next_dist=_queue_head;
+		        }
+		    }
 		    ///Processes the next node.
 		    ///Processes the next node.
 		    ///
 		    ///\return The processed node.
 		    ///
 		    ///\pre The queue must not be empty.
 		    Node processNextNode()
+		    {
 		      if(_queue_tail==_queue_next_dist) {
 		        _curr_dist++;
 		        _queue_next_dist=_queue_head;
+		      }
 		      Node n=_queue[_queue_tail++];
 		      _processed->set(n,true);
 		      Node m;
 		      for(OutArcIt e(*G,n);e!=INVALID;++e)
 		        if(!(*_reached)[m=G->target(e)]) {
 		          _queue[_queue_head++]=m;
 		          _reached->set(m,true);
 		          _pred->set(m,e);
 		          _dist->set(m,_curr_dist);
+		        }
 		      return n;
+		    }
 		    ///Processes the next node.
 		    ///Processes the next node and checks if the given target node
 		    ///is reached. If the target node is reachable from the processed
 		    ///node, then the \c reach parameter will be set to \c true.
 		    ///
 		    ///\param target The target node.
 		    ///\retval reach Indicates if the target node is reached.
 		    ///It should be initially \c false.
 		    ///
 		    ///\return The processed node.
 		    ///
 		    ///\pre The queue must not be empty.
 		    Node processNextNode(Node target, bool& reach)
+		    {
 		      if(_queue_tail==_queue_next_dist) {
 		        _curr_dist++;
 		        _queue_next_dist=_queue_head;
+		      }
 		      Node n=_queue[_queue_tail++];
 		      _processed->set(n,true);
 		      Node m;
 		      for(OutArcIt e(*G,n);e!=INVALID;++e)
 		        if(!(*_reached)[m=G->target(e)]) {
 		          _queue[_queue_head++]=m;
 		          _reached->set(m,true);
 		          _pred->set(m,e);
 		          _dist->set(m,_curr_dist);
 		          reach = reach || (target == m);
+		        }
 		      return n;
+		    }
 		    ///Processes the next node.
 		    ///Processes the next node and checks if at least one of reached
 		    ///nodes has \c true value in the \c nm node map. If one node
 		    ///with \c true value is reachable from the processed node, then the
 		    ///\c rnode parameter will be set to the first of such nodes.
 		    ///
 		    ///\param nm A \c bool (or convertible) node map that indicates the
 		    ///possible targets.
 		    ///\retval rnode The reached target node.
 		    ///It should be initially \c INVALID.
 		    ///
 		    ///\return The processed node.
 		    ///
 		    ///\pre The queue must not be empty.
 		    template<class NM>
 		    Node processNextNode(const NM& nm, Node& rnode)
+		    {
 		      if(_queue_tail==_queue_next_dist) {
 		        _curr_dist++;
 		        _queue_next_dist=_queue_head;
+		      }
 		      Node n=_queue[_queue_tail++];
 		      _processed->set(n,true);
 		      Node m;
 		      for(OutArcIt e(*G,n);e!=INVALID;++e)
 		        if(!(*_reached)[m=G->target(e)]) {
 		          _queue[_queue_head++]=m;
 		          _reached->set(m,true);
 		          _pred->set(m,e);
 		          _dist->set(m,_curr_dist);
 		          if (nm[m] && rnode == INVALID) rnode = m;
+		        }
 		      return n;
+		    }
 		    ///The next node to be processed.
 		    ///Returns the next node to be processed or \c INVALID if the queue
 		    ///is empty.
 		    Node nextNode() const
+		    {
 		      return _queue_tail<_queue_head?_queue[_queue_tail]:INVALID;
+		    }
 		    ///Returns \c false if there are nodes to be processed.
 		    ///Returns \c false if there are nodes to be processed
 		    ///in the queue.
 		    bool emptyQueue() const { return _queue_tail==_queue_head; }
 		    ///Returns the number of the nodes to be processed.
 		    ///Returns the number of the nodes to be processed
 		    ///in the queue.
 		    int queueSize() const { return _queue_head-_queue_tail; }
 		    ///Executes the algorithm.
 		    ///Executes the algorithm.
 		    ///
 		    ///This method runs the %BFS algorithm from the root node(s)
 		    ///in order to compute the shortest path to each node.
 		    ///
 		    ///The algorithm computes
 		    ///- the shortest path tree (forest),
 		    ///- the distance of each node from the root(s).
 		    ///
 		    ///\pre init() must be called and at least one root node should be
 		    ///added with addSource() before using this function.
 		    ///
 		    ///\note <tt>b.start()</tt> is just a shortcut of the following code.
 		    ///\code
 		    ///  while ( !b.emptyQueue() ) {
 		    ///    b.processNextNode();
 		    ///  }
 		    ///\endcode
 		    void start()
+		    {
 		      while ( !emptyQueue() ) processNextNode();
+		    }
 		    ///Executes the algorithm until the given target node is reached.
 		    ///Executes the algorithm until the given target node is reached.
 		    ///
 		    ///This method runs the %BFS algorithm from the root node(s)
 		    ///in order to compute the shortest path to \c t.
 		    ///
 		    ///The algorithm computes
 		    ///- the shortest path to \c t,
 		    ///- the distance of \c t from the root(s).
 		    ///
 		    ///\pre init() must be called and at least one root node should be
 		    ///added with addSource() before using this function.
 		    ///
 		    ///\note <tt>b.start(t)</tt> is just a shortcut of the following code.
 		    ///\code
 		    ///  bool reach = false;
 		    ///  while ( !b.emptyQueue() && !reach ) {
 		    ///    b.processNextNode(t, reach);
 		    ///  }
 		    ///\endcode
 		    void start(Node t)
+		    {
 		      bool reach = false;
 		      while ( !emptyQueue() && !reach ) processNextNode(t, reach);
+		    }
 		    ///Executes the algorithm until a condition is met.
 		    ///Executes the algorithm until a condition is met.
 		    ///
 		    ///This method runs the %BFS algorithm from the root node(s) in
 		    ///order to compute the shortest path to a node \c v with
 		    /// <tt>nm[v]</tt> true, if such a node can be found.
 		    ///
 		    ///\param nm A \c bool (or convertible) node map. The algorithm
 		    ///will stop when it reaches a node \c v with <tt>nm[v]</tt> true.
 		    ///
 		    ///\return The reached node \c v with <tt>nm[v]</tt> true or
 		    ///\c INVALID if no such node was found.
 		    ///
 		    ///\pre init() must be called and at least one root node should be
 		    ///added with addSource() before using this function.
 		    ///
 		    ///\note <tt>b.start(nm)</tt> is just a shortcut of the following code.
 		    ///\code
 		    ///  Node rnode = INVALID;
 		    ///  while ( !b.emptyQueue() && rnode == INVALID ) {
 		    ///    b.processNextNode(nm, rnode);
 		    ///  }
 		    ///  return rnode;
 		    ///\endcode
 		    template<class NodeBoolMap>
 		    Node start(const NodeBoolMap &nm)
+		    {
 		      Node rnode = INVALID;
 		      while ( !emptyQueue() && rnode == INVALID ) {
 		        processNextNode(nm, rnode);
+		      }
 		      return rnode;
+		    }
 		    ///Runs the algorithm from the given source node.
 		    ///This method runs the %BFS algorithm from node \c s
 		    ///in order to compute the shortest path to each node.
 		    ///
 		    ///The algorithm computes
 		    ///- the shortest path tree,
 		    ///- the distance of each node from the root.
 		    ///
 		    ///\note <tt>b.run(s)</tt> is just a shortcut of the following code.
 		    ///\code
 		    ///  b.init();
 		    ///  b.addSource(s);
 		    ///  b.start();
 		    ///\endcode
 		    void run(Node s) {
@@ -1169,514 +1169,514 @@
 		  ///they are declared as the members of class \ref BfsWizard.
 		  ///The following examples show how to use these parameters.
 		  ///\code
 		  ///  // Compute shortest path from node s to each node
 		  ///  bfs(g).predMap(preds).distMap(dists).run(s);
 		  ///
 		  ///  // Compute shortest path from s to t
 		  ///  bool reached = bfs(g).path(p).dist(d).run(s,t);
 		  ///\endcode
 		  ///\warning Don't forget to put the \ref BfsWizard::run(Node) "run()"
 		  ///to the end of the parameter list.
 		  ///\sa BfsWizard
 		  ///\sa Bfs
 		  template<class GR>
 		  BfsWizard<BfsWizardBase<GR> >
 		  bfs(const GR &digraph)
+		  {
 		    return BfsWizard<BfsWizardBase<GR> >(digraph);
+		  }
 		#ifdef DOXYGEN
 		  /// \brief Visitor class for BFS.
 		  ///
 		  /// This class defines the interface of the BfsVisit events, and
 		  /// it could be the base of a real visitor class.
 		  template <typename GR>
 		  struct BfsVisitor {
 		    typedef GR Digraph;
 		    typedef typename Digraph::Arc Arc;
 		    typedef typename Digraph::Node Node;
 		    /// \brief Called for the source node(s) of the BFS.
 		    ///
 		    /// This function is called for the source node(s) of the BFS.
 		    void start(const Node& node) {}
 		    /// \brief Called when a node is reached first time.
 		    ///
 		    /// This function is called when a node is reached first time.
 		    void reach(const Node& node) {}
 		    /// \brief Called when a node is processed.
 		    ///
 		    /// This function is called when a node is processed.
 		    void process(const Node& node) {}
 		    /// \brief Called when an arc reaches a new node.
 		    ///
 		    /// This function is called when the BFS finds an arc whose target node
 		    /// is not reached yet.
 		    void discover(const Arc& arc) {}
 		    /// \brief Called when an arc is examined but its target node is
 		    /// already discovered.
 		    ///
 		    /// This function is called when an arc is examined but its target node is
 		    /// already discovered.
 		    void examine(const Arc& arc) {}
 		  };
 		#else
 		  template <typename GR>
 		  struct BfsVisitor {
 		    typedef GR Digraph;
 		    typedef typename Digraph::Arc Arc;
 		    typedef typename Digraph::Node Node;
 		    void start(const Node&) {}
 		    void reach(const Node&) {}
 		    void process(const Node&) {}
 		    void discover(const Arc&) {}
 		    void examine(const Arc&) {}
 		    template <typename _Visitor>
 		    struct Constraints {
 		      void constraints() {
 		        Arc arc;
 		        Node node;
 		        visitor.start(node);
 		        visitor.reach(node);
 		        visitor.process(node);
 		        visitor.discover(arc);
 		        visitor.examine(arc);
+		      }
 		      _Visitor& visitor;
 		    };
 		  };
 		#endif
 		  /// \brief Default traits class of BfsVisit class.
 		  ///
 		  /// Default traits class of BfsVisit class.
 		  /// \tparam GR The type of the digraph the algorithm runs on.
 		  template<class GR>
 		  struct BfsVisitDefaultTraits {
 		    /// \brief The type of the digraph the algorithm runs on.
 		    typedef GR Digraph;
 		    /// \brief The type of the map that indicates which nodes are reached.
 		    ///
 		    /// The type of the map that indicates which nodes are reached.
 		    /// It must conform to the \ref concepts::ReadWriteMap "ReadWriteMap" concept.
 		    typedef typename Digraph::template NodeMap<bool> ReachedMap;
 		    /// \brief Instantiates a ReachedMap.
 		    ///
 		    /// This function instantiates a ReachedMap.
 		    /// \param digraph is the digraph, to which
 		    /// we would like to define the ReachedMap.
 		    static ReachedMap *createReachedMap(const Digraph &digraph) {
 		      return new ReachedMap(digraph);
+		    }
 		  };
 		  /// \ingroup search
 		  ///
 		  /// \brief BFS algorithm class with visitor interface.
 		  ///
 		  /// This class provides an efficient implementation of the BFS algorithm
 		  /// with visitor interface.
 		  ///
 		  /// The BfsVisit class provides an alternative interface to the Bfs
 		  /// class. It works with callback mechanism, the BfsVisit object calls
 		  /// the member functions of the \c Visitor class on every BFS event.
 		  ///
 		  /// This interface of the BFS algorithm should be used in special cases
 		  /// when extra actions have to be performed in connection with certain
 		  /// events of the BFS algorithm. Otherwise consider to use Bfs or bfs()
 		  /// instead.
 		  ///
 		  /// \tparam GR The type of the digraph the algorithm runs on.
 		  /// The default type is \ref ListDigraph.
 		  /// The value of GR is not used directly by \ref BfsVisit,
 		  /// it is only passed to \ref BfsVisitDefaultTraits.
 		  /// \tparam VS The Visitor type that is used by the algorithm.
 		  /// \ref BfsVisitor "BfsVisitor<GR>" is an empty visitor, which
 		  /// does not observe the BFS events. If you want to observe the BFS
 		  /// events, you should implement your own visitor class.
 		  /// \tparam TR Traits class to set various data types used by the
 		  /// algorithm. The default traits class is
 		  /// \ref BfsVisitDefaultTraits "BfsVisitDefaultTraits<GR>".
 		  /// See \ref BfsVisitDefaultTraits for the documentation of
 		  /// a BFS visit traits class.
 		#ifdef DOXYGEN
 		  template <typename GR, typename VS, typename TR>
 		#else
 		  template <typename GR = ListDigraph,
 		            typename VS = BfsVisitor<GR>,
 		            typename TR = BfsVisitDefaultTraits<GR> >
 		#endif
 		  class BfsVisit {
 		  public:
 		    ///The traits class.
 		    typedef TR Traits;
 		    ///The type of the digraph the algorithm runs on.
 		    typedef typename Traits::Digraph Digraph;
 		    ///The visitor type used by the algorithm.
 		    typedef VS Visitor;
 		    ///The type of the map that indicates which nodes are reached.
 		    typedef typename Traits::ReachedMap ReachedMap;
 		  private:
 		    typedef typename Digraph::Node Node;
 		    typedef typename Digraph::NodeIt NodeIt;
 		    typedef typename Digraph::Arc Arc;
 		    typedef typename Digraph::OutArcIt OutArcIt;
 		    //Pointer to the underlying digraph.
 		    const Digraph *_digraph;
 		    //Pointer to the visitor object.
 		    Visitor *_visitor;
 		    //Pointer to the map of reached status of the nodes.
 		    ReachedMap *_reached;
 		    //Indicates if _reached is locally allocated (true) or not.
 		    bool local_reached;
 		    std::vector<typename Digraph::Node> _list;
 		    int _list_front, _list_back;
 		    //Creates the maps if necessary.
 		    void create_maps() {
 		      if(!_reached) {
 		        local_reached = true;
 		        _reached = Traits::createReachedMap(*_digraph);
+		      }
+		    }
 		  protected:
 		    BfsVisit() {}
 		  public:
 		    typedef BfsVisit Create;
 		    /// \name Named Template Parameters
 		    ///@{
 		    template <class T>
 		    struct SetReachedMapTraits : public Traits {
 		      typedef T ReachedMap;
 		      static ReachedMap *createReachedMap(const Digraph &digraph) {
 		        LEMON_ASSERT(false, "ReachedMap is not initialized");
 		        return 0; // ignore warnings
+		      }
 		    };
 		    /// \brief \ref named-templ-param "Named parameter" for setting
 		    /// ReachedMap type.
 		    ///
 		    /// \ref named-templ-param "Named parameter" for setting ReachedMap type.
 		    template <class T>
 		    struct SetReachedMap : public BfsVisit< Digraph, Visitor,
 		                                            SetReachedMapTraits<T> > {
 		      typedef BfsVisit< Digraph, Visitor, SetReachedMapTraits<T> > Create;
 		    };
 		    ///@}
 		  public:
 		    /// \brief Constructor.
 		    ///
 		    /// Constructor.
 		    ///
 		    /// \param digraph The digraph the algorithm runs on.
 		    /// \param visitor The visitor object of the algorithm.
 		    BfsVisit(const Digraph& digraph, Visitor& visitor)
 		      : _digraph(&digraph), _visitor(&visitor),
 		        _reached(0), local_reached(false) {}
 		    /// \brief Destructor.
 		    ~BfsVisit() {
 		      if(local_reached) delete _reached;
+		    }
 		    /// \brief Sets the map that indicates which nodes are reached.
 		    ///
 		    /// Sets the map that indicates which nodes are reached.
 		    /// If you don't use this function before calling \ref run(Node) "run()"
 		    /// or \ref init(), an instance will be allocated automatically.
 		    /// The destructor deallocates this automatically allocated map,
 		    /// of course.
 		    /// \return <tt> (*this) </tt>
 		    BfsVisit &reachedMap(ReachedMap &m) {
 		      if(local_reached) {
 		        delete _reached;
 		        local_reached = false;
+		      }
 		      _reached = &m;
 		      return *this;
+		    }
 		  public:
 		    /// \name Execution Control
 		    /// The simplest way to execute the BFS algorithm is to use one of the
 		    /// member functions called \ref run(Node) "run()".\n
 		    /// If you need more control on the execution, first you have to call
 		    /// \ref init(), then you can add several source nodes with
 		    /// If you need better control on the execution, you have to call
 		    /// \ref init() first, then you can add several source nodes with
 		    /// \ref addSource(). Finally the actual path computation can be
 		    /// performed with one of the \ref start() functions.
 		    /// @{
 		    /// \brief Initializes the internal data structures.
 		    ///
 		    /// Initializes the internal data structures.
 		    void init() {
 		      create_maps();
 		      _list.resize(countNodes(*_digraph));
 		      _list_front = _list_back = -1;
 		      for (NodeIt u(*_digraph) ; u != INVALID ; ++u) {
 		        _reached->set(u, false);
+		      }
+		    }
 		    /// \brief Adds a new source node.
 		    ///
 		    /// Adds a new source node to the set of nodes to be processed.
 		    void addSource(Node s) {
 		      if(!(*_reached)[s]) {
 		          _reached->set(s,true);
 		          _visitor->start(s);
 		          _visitor->reach(s);
 		          _list[++_list_back] = s;
+		        }
+		    }
 		    /// \brief Processes the next node.
 		    ///
 		    /// Processes the next node.
 		    ///
 		    /// \return The processed node.
 		    ///
 		    /// \pre The queue must not be empty.
 		    Node processNextNode() {
 		      Node n = _list[++_list_front];
 		      _visitor->process(n);
 		      Arc e;
 		      for (_digraph->firstOut(e, n); e != INVALID; _digraph->nextOut(e)) {
 		        Node m = _digraph->target(e);
 		        if (!(*_reached)[m]) {
 		          _visitor->discover(e);
 		          _visitor->reach(m);
 		          _reached->set(m, true);
 		          _list[++_list_back] = m;
 		        } else {
 		          _visitor->examine(e);
+		        }
+		      }
 		      return n;
+		    }
 		    /// \brief Processes the next node.
 		    ///
 		    /// Processes the next node and checks if the given target node
 		    /// is reached. If the target node is reachable from the processed
 		    /// node, then the \c reach parameter will be set to \c true.
 		    ///
 		    /// \param target The target node.
 		    /// \retval reach Indicates if the target node is reached.
 		    /// It should be initially \c false.
 		    ///
 		    /// \return The processed node.
 		    ///
 		    /// \pre The queue must not be empty.
 		    Node processNextNode(Node target, bool& reach) {
 		      Node n = _list[++_list_front];
 		      _visitor->process(n);
 		      Arc e;
 		      for (_digraph->firstOut(e, n); e != INVALID; _digraph->nextOut(e)) {
 		        Node m = _digraph->target(e);
 		        if (!(*_reached)[m]) {
 		          _visitor->discover(e);
 		          _visitor->reach(m);
 		          _reached->set(m, true);
 		          _list[++_list_back] = m;
 		          reach = reach || (target == m);
 		        } else {
 		          _visitor->examine(e);
+		        }
+		      }
 		      return n;
+		    }
 		    /// \brief Processes the next node.
 		    ///
 		    /// Processes the next node and checks if at least one of reached
 		    /// nodes has \c true value in the \c nm node map. If one node
 		    /// with \c true value is reachable from the processed node, then the
 		    /// \c rnode parameter will be set to the first of such nodes.
 		    ///
 		    /// \param nm A \c bool (or convertible) node map that indicates the
 		    /// possible targets.
 		    /// \retval rnode The reached target node.
 		    /// It should be initially \c INVALID.
 		    ///
 		    /// \return The processed node.
 		    ///
 		    /// \pre The queue must not be empty.
 		    template <typename NM>
 		    Node processNextNode(const NM& nm, Node& rnode) {
 		      Node n = _list[++_list_front];
 		      _visitor->process(n);
 		      Arc e;
 		      for (_digraph->firstOut(e, n); e != INVALID; _digraph->nextOut(e)) {
 		        Node m = _digraph->target(e);
 		        if (!(*_reached)[m]) {
 		          _visitor->discover(e);
 		          _visitor->reach(m);
 		          _reached->set(m, true);
 		          _list[++_list_back] = m;
 		          if (nm[m] && rnode == INVALID) rnode = m;
 		        } else {
 		          _visitor->examine(e);
+		        }
+		      }
 		      return n;
+		    }
 		    /// \brief The next node to be processed.
 		    ///
 		    /// Returns the next node to be processed or \c INVALID if the queue
 		    /// is empty.
 		    Node nextNode() const {
 		      return _list_front != _list_back ? _list[_list_front + 1] : INVALID;
+		    }
 		    /// \brief Returns \c false if there are nodes
 		    /// to be processed.
 		    ///
 		    /// Returns \c false if there are nodes
 		    /// to be processed in the queue.
 		    bool emptyQueue() const { return _list_front == _list_back; }
 		    /// \brief Returns the number of the nodes to be processed.
 		    ///
 		    /// Returns the number of the nodes to be processed in the queue.
 		    int queueSize() const { return _list_back - _list_front; }
 		    /// \brief Executes the algorithm.
 		    ///
 		    /// Executes the algorithm.
 		    ///
 		    /// This method runs the %BFS algorithm from the root node(s)
 		    /// in order to compute the shortest path to each node.
 		    ///
 		    /// The algorithm computes
 		    /// - the shortest path tree (forest),
 		    /// - the distance of each node from the root(s).
 		    ///
 		    /// \pre init() must be called and at least one root node should be added
 		    /// with addSource() before using this function.
 		    ///
 		    /// \note <tt>b.start()</tt> is just a shortcut of the following code.
 		    /// \code
 		    ///   while ( !b.emptyQueue() ) {
 		    ///     b.processNextNode();
 		    ///   }
 		    /// \endcode
 		    void start() {
 		      while ( !emptyQueue() ) processNextNode();
+		    }
 		    /// \brief Executes the algorithm until the given target node is reached.
 		    ///
 		    /// Executes the algorithm until the given target node is reached.
 		    ///
 		    /// This method runs the %BFS algorithm from the root node(s)
 		    /// in order to compute the shortest path to \c t.
 		    ///
 		    /// The algorithm computes
 		    /// - the shortest path to \c t,
 		    /// - the distance of \c t from the root(s).
 		    ///
 		    /// \pre init() must be called and at least one root node should be
 		    /// added with addSource() before using this function.
 		    ///
 		    /// \note <tt>b.start(t)</tt> is just a shortcut of the following code.
 		    /// \code
 		    ///   bool reach = false;
 		    ///   while ( !b.emptyQueue() && !reach ) {
 		    ///     b.processNextNode(t, reach);
 		    ///   }
 		    /// \endcode
 		    void start(Node t) {
 		      bool reach = false;
 		      while ( !emptyQueue() && !reach ) processNextNode(t, reach);
+		    }
 		    /// \brief Executes the algorithm until a condition is met.
 		    ///
 		    /// Executes the algorithm until a condition is met.
 		    ///
 		    /// This method runs the %BFS algorithm from the root node(s) in
 		    /// order to compute the shortest path to a node \c v with
 		    /// <tt>nm[v]</tt> true, if such a node can be found.
 		    ///
 		    /// \param nm must be a bool (or convertible) node map. The
 		    /// algorithm will stop when it reaches a node \c v with
 		    /// <tt>nm[v]</tt> true.
 		    ///
 		    /// \return The reached node \c v with <tt>nm[v]</tt> true or
 		    /// \c INVALID if no such node was found.
 		    ///
 		    /// \pre init() must be called and at least one root node should be
 		    /// added with addSource() before using this function.
 		    ///
 		    /// \note <tt>b.start(nm)</tt> is just a shortcut of the following code.
 		    /// \code
 		    ///   Node rnode = INVALID;
 		    ///   while ( !b.emptyQueue() && rnode == INVALID ) {
 		    ///     b.processNextNode(nm, rnode);
 		    ///   }
 		    ///   return rnode;
 		    /// \endcode
 		    template <typename NM>
 		    Node start(const NM &nm) {
 		      Node rnode = INVALID;
 		      while ( !emptyQueue() && rnode == INVALID ) {
 		        processNextNode(nm, rnode);
+		      }
 		      return rnode;
+		    }
 		    /// \brief Runs the algorithm from the given source node.
 		    ///
 		    /// This method runs the %BFS algorithm from node \c s
 		    /// in order to compute the shortest path to each node.
 		    ///
 		    /// The algorithm computes
 		    /// - the shortest path tree,
 		    /// - the distance of each node from the root.
 		    ///
 		    /// \note <tt>b.run(s)</tt> is just a shortcut of the following code.
 		    ///\code
 		    ///   b.init();
 		    ///   b.addSource(s);
 		    ///   b.start();
 		    ///\endcode
 		    void run(Node s) {
 		      init();
 		      addSource(s);
 		      start();
+		    }
 		    /// \brief Finds the shortest path between \c s and \c t.
 		    ///
 		    /// This method runs the %BFS algorithm from node \c s
 		    /// in order to compute the shortest path to node \c t
 		    /// (it stops searching when \c t is processed).
 		    ///
 		    /// \return \c true if \c t is reachable form \c s.
 		    ///
 		    /// \note Apart from the return value, <tt>b.run(s,t)</tt> is just a

lemon/bin_heap.h

Show inline comments

 		/* -*- mode: C++; indent-tabs-mode: nil; -*-
+		 *
 		 * This file is a part of LEMON, a generic C++ optimization library.
+		 *
 		 * 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_BIN_HEAP_H
 		#define LEMON_BIN_HEAP_H
-		///\ingroup auxdat
+		///\ingroup heaps
 		///\file
-		///\brief Binary Heap implementation.
+		///\brief Binary heap implementation.
 		#include <vector>
 		#include <utility>
 		#include <functional>
 		namespace lemon {
-		  ///\ingroup auxdat
+		  /// \ingroup heaps
 		  ///
-		  ///\brief A Binary Heap implementation.
+		  /// \brief Binary heap data structure.
 		  ///
 		  ///This class implements the \e binary \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 Comp 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 binary \e heap data structure.
 		  /// It fully conforms to the \ref concepts::Heap "heap concept".
 		  ///
 		  ///\tparam PR Type of the priority of the items.
 		  ///\tparam IM A read and writable item map with int values, used internally
 		  ///to handle the cross references.
 		  ///\tparam Comp A functor class for the ordering of the priorities.
 		  ///The default is \c std::less<PR>.
 		  ///
 		  ///\sa FibHeap
 		  ///\sa Dijkstra
-		  template <typename PR, typename IM, typename Comp = std::less<PR> >
+		  /// \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 PR, typename IM, typename CMP>
 		#else
 		  template <typename PR, typename IM, typename CMP = std::less<PR> >
 		#endif
 		  class BinHeap {
 		  public:
 		  public:
 		    ///\e
 		    /// Type of the item-int map.
 		    typedef IM ItemIntMap;
-		    ///\e
+		    /// Type of the priorities.
 		    typedef PR Prio;
-		    ///\e
+		    /// Type of the items stored in the heap.
 		    typedef typename ItemIntMap::Key Item;
-		    ///\e
+		    /// Type of the item-priority pairs.
 		    typedef std::pair<Item,Prio> Pair;
 		    ///\e
 		    typedef Comp Compare;
 		    /// Functor type for comparing the priorities.
 		    typedef CMP 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 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:
 		    std::vector<Pair> _data;
 		    Compare _comp;
 		    ItemIntMap &_iim;
 		  public:
-		    /// \brief The constructor.
 		    /// \brief Constructor.
 		    ///
 		    /// The constructor.
 		    /// \param map should be given to the constructor, since it is used
 		    /// internally to handle the cross references. The value of the map
 		    /// must be \c PRE_HEAP (<tt>-1</tt>) for every item.
 		    /// 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 BinHeap(ItemIntMap &map) : _iim(map) {}
-		    /// \brief The constructor.
+		    /// \brief Constructor.
 		    ///
 		    /// The constructor.
 		    /// \param map 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.
 		    ///
 		    /// \param comp The comparator function object.
 		    /// 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.
 		    BinHeap(ItemIntMap &map, const Compare &comp)
 		      : _iim(map), _comp(comp) {}
 		    /// The number of items stored in the heap.
+		    /// \brief The number of items stored in the heap.
 		    ///
-		    /// \brief Returns the number of items stored in the heap.
+		    /// This function returns the number of items stored in the heap.
 		    int size() const { return _data.size(); }
-		    /// \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.
+		    /// This function returns \c true if the heap is empty.
 		    bool empty() const { return _data.empty(); }
-		    /// \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 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() {
 		      _data.clear();
+		    }
 		  private:
 		    static int parent(int i) { return (i-1)/2; }
-		    static int second_child(int i) { return 2*i+2; }
+		    static int secondChild(int i) { return 2*i+2; }
 		    bool less(const Pair &p1, const Pair &p2) const {
 		      return _comp(p1.second, p2.second);
+		    }
-		    int bubble_up(int hole, Pair p) {
+		    int bubbleUp(int hole, Pair p) {
 		      int par = parent(hole);
 		      while( hole>0 && less(p,_data[par]) ) {
 		        move(_data[par],hole);
 		        hole = par;
 		        par = parent(hole);
+		      }
 		      move(p, hole);
 		      return hole;
+		    }
 		    int bubble_down(int hole, Pair p, int length) {
 		      int child = second_child(hole);
 		    int bubbleDown(int hole, Pair p, int length) {
 		      int child = secondChild(hole);
 		      while(child < length) {
 		        if( less(_data[child-1], _data[child]) ) {
 		          --child;
+		        }
 		        if( !less(_data[child], p) )
 		          goto ok;
 		        move(_data[child], hole);
 		        hole = child;
-		        child = second_child(hole);
+		        child = secondChild(hole);
+		      }
 		      child--;
 		      if( child<length && less(_data[child], p) ) {
 		        move(_data[child], hole);
 		        hole=child;
+		      }
 		    ok:
 		      move(p, hole);
 		      return hole;
+		    }
 		    void move(const Pair &p, int 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);
+		      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.
+		    /// 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.
 		    /// 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);
+		        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);
 		      if( h < n ) {
 		        if ( bubble_up(h, _data[n]) == h) {
 		          bubble_down(h, _data[n], n);
 		        if ( bubbleUp(h, _data[n]) == h) {
 		          bubbleDown(h, _data[n], n);
+		        }
+		      }
 		      _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.
+		    /// This function returns the priority of the given item.
 		    /// \param i The item.
-		    /// \pre \c i must be in the heap.
+		    /// \pre \e i must be in the heap.
 		    Prio operator[](const Item &i) const {
 		      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];
 		      if( idx < 0 ) {
 		        push(i,p);
+		      }
 		      else if( _comp(p, _data[idx].second) ) {
-		        bubble_up(idx, Pair(i,p));
+		        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.
+		    /// This function decreases the priority of an item to the given value.
 		    /// \param i The item.
 		    /// \param p The priority.
 		    /// \pre \c i must be stored in the heap with priority at least \c
 		    /// p relative to \c Compare.
 		    /// \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));
+		      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.
+		    /// This function increases the priority of an item to the given value.
 		    /// \param i The item.
 		    /// \param p The priority.
 		    /// \pre \c i must be stored in the heap with priority at most \c
 		    /// p relative to \c Compare.
 		    /// \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());
+		      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];
 		      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;
+		      }
+		    }
-		    /// \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;
+		    }
 		  }; // class BinHeap
 		} // namespace lemon
 		#endif // LEMON_BIN_HEAP_H

lemon/bits/edge_set_extender.h

Show inline comments

@@ -284,342 +284,342 @@
 		    typedef typename Parent::Arc Arc;
 		    typedef typename Parent::Edge Edge;
 		    int maxId(Node) const {
 		      return Parent::maxNodeId();
+		    }
 		    int maxId(Arc) const {
 		      return Parent::maxArcId();
+		    }
 		    int maxId(Edge) const {
 		      return Parent::maxEdgeId();
+		    }
 		    Node fromId(int id, Node) const {
 		      return Parent::nodeFromId(id);
+		    }
 		    Arc fromId(int id, Arc) const {
 		      return Parent::arcFromId(id);
+		    }
 		    Edge fromId(int id, Edge) const {
 		      return Parent::edgeFromId(id);
+		    }
 		    Node oppositeNode(const Node &n, const Edge &e) const {
 		      if( n == Parent::u(e))
 			return Parent::v(e);
 		      else if( n == Parent::v(e))
 			return Parent::u(e);
 		      else
 			return INVALID;
+		    }
 		    Arc oppositeArc(const Arc &e) const {
 		      return Parent::direct(e, !Parent::direction(e));
+		    }
 		    using Parent::direct;
 		    Arc direct(const Edge &e, const Node &s) const {
 		      return Parent::direct(e, Parent::u(e) == s);
+		    }
 		    typedef AlterationNotifier<EdgeSetExtender, Arc> ArcNotifier;
 		    typedef AlterationNotifier<EdgeSetExtender, Edge> EdgeNotifier;
 		  protected:
 		    mutable ArcNotifier arc_notifier;
 		    mutable EdgeNotifier edge_notifier;
 		  public:
 		    using Parent::notifier;
 		    ArcNotifier& notifier(Arc) const {
 		      return arc_notifier;
+		    }
 		    EdgeNotifier& notifier(Edge) const {
 		      return edge_notifier;
+		    }
 		    class NodeIt : public Node {
 		      const Graph* graph;
 		    public:
 		      NodeIt() {}
 		      NodeIt(Invalid i) : Node(i) { }
 		      explicit NodeIt(const Graph& _graph) : graph(&_graph) {
 			_graph.first(static_cast<Node&>(*this));
+		      }
 		      NodeIt(const Graph& _graph, const Node& node)
 			: Node(node), graph(&_graph) {}
 		      NodeIt& operator++() {
 			graph->next(*this);
 			return *this;
+		      }
 		    };
 		    class ArcIt : public Arc {
 		      const Graph* graph;
 		    public:
 		      ArcIt() { }
 		      ArcIt(Invalid i) : Arc(i) { }
 		      explicit ArcIt(const Graph& _graph) : graph(&_graph) {
 			_graph.first(static_cast<Arc&>(*this));
+		      }
 		      ArcIt(const Graph& _graph, const Arc& e) :
 			Arc(e), graph(&_graph) { }
 		      ArcIt& operator++() {
 			graph->next(*this);
 			return *this;
+		      }
 		    };
 		    class OutArcIt : public Arc {
 		      const Graph* graph;
 		    public:
 		      OutArcIt() { }
 		      OutArcIt(Invalid i) : Arc(i) { }
 		      OutArcIt(const Graph& _graph, const Node& node)
 			: graph(&_graph) {
 			_graph.firstOut(*this, node);
+		      }
 		      OutArcIt(const Graph& _graph, const Arc& arc)
 			: Arc(arc), graph(&_graph) {}
 		      OutArcIt& operator++() {
 			graph->nextOut(*this);
 			return *this;
+		      }
 		    };
 		    class InArcIt : public Arc {
 		      const Graph* graph;
 		    public:
 		      InArcIt() { }
 		      InArcIt(Invalid i) : Arc(i) { }
 		      InArcIt(const Graph& _graph, const Node& node)
 			: graph(&_graph) {
 			_graph.firstIn(*this, node);
+		      }
 		      InArcIt(const Graph& _graph, const Arc& arc) :
 			Arc(arc), graph(&_graph) {}
 		      InArcIt& operator++() {
 			graph->nextIn(*this);
 			return *this;
+		      }
 		    };
 		    class EdgeIt : public Parent::Edge {
 		      const Graph* graph;
 		    public:
 		      EdgeIt() { }
 		      EdgeIt(Invalid i) : Edge(i) { }
 		      explicit EdgeIt(const Graph& _graph) : graph(&_graph) {
 			_graph.first(static_cast<Edge&>(*this));
+		      }
 		      EdgeIt(const Graph& _graph, const Edge& e) :
 			Edge(e), graph(&_graph) { }
 		      EdgeIt& operator++() {
 			graph->next(*this);
 			return *this;
+		      }
 		    };
 		    class IncEdgeIt : public Parent::Edge {
 		      friend class EdgeSetExtender;
 		      const Graph* graph;
 		      bool direction;
 		    public:
 		      IncEdgeIt() { }
 		      IncEdgeIt(Invalid i) : Edge(i), direction(false) { }
 		      IncEdgeIt(const Graph& _graph, const Node &n) : graph(&_graph) {
 			_graph.firstInc(*this, direction, n);
+		      }
 		      IncEdgeIt(const Graph& _graph, const Edge &ue, const Node &n)
 			: graph(&_graph), Edge(ue) {
 			direction = (_graph.source(ue) == n);
+		      }
 		      IncEdgeIt& operator++() {
 			graph->nextInc(*this, direction);
 			return *this;
+		      }
 		    };
 		    // \brief Base node of the iterator
 		    //
 		    // Returns the base node (ie. the source in this case) of the iterator
 		    Node baseNode(const OutArcIt &e) const {
 		      return Parent::source(static_cast<const Arc&>(e));
+		    }
 		    // \brief Running node of the iterator
 		    //
 		    // Returns the running node (ie. the target in this case) of the
 		    // iterator
 		    Node runningNode(const OutArcIt &e) const {
 		      return Parent::target(static_cast<const Arc&>(e));
+		    }
 		    // \brief Base node of the iterator
 		    //
 		    // Returns the base node (ie. the target in this case) of the iterator
 		    Node baseNode(const InArcIt &e) const {
 		      return Parent::target(static_cast<const Arc&>(e));
+		    }
 		    // \brief Running node of the iterator
 		    //
 		    // Returns the running node (ie. the source in this case) of the
 		    // iterator
 		    Node runningNode(const InArcIt &e) const {
 		      return Parent::source(static_cast<const Arc&>(e));
+		    }
 		    // Base node of the iterator
 		    //
 		    // Returns the base node of the iterator
 		    Node baseNode(const IncEdgeIt &e) const {
 		      return e.direction ? u(e) : v(e);
+		    }
 		    // Running node of the iterator
 		    //
 		    // Returns the running node of the iterator
 		    Node runningNode(const IncEdgeIt &e) const {
 		      return e.direction ? v(e) : u(e);
+		    }
 		    template <typename _Value>
 		    class ArcMap
 		      : public MapExtender<DefaultMap<Graph, Arc, _Value> > {
 		      typedef MapExtender<DefaultMap<Graph, Arc, _Value> > Parent;
 		    public:
 		      ArcMap(const Graph& _g)
+		      explicit ArcMap(const Graph& _g)
 			: Parent(_g) {}
 		      ArcMap(const Graph& _g, const _Value& _v)
 			: Parent(_g, _v) {}
 		      ArcMap& operator=(const ArcMap& cmap) {
 			return operator=<ArcMap>(cmap);
+		      }
 		      template <typename CMap>
 		      ArcMap& operator=(const CMap& cmap) {
 		        Parent::operator=(cmap);
 			return *this;
+		      }
 		    };
 		    template <typename _Value>
 		    class EdgeMap
 		      : public MapExtender<DefaultMap<Graph, Edge, _Value> > {
 		      typedef MapExtender<DefaultMap<Graph, Edge, _Value> > Parent;
 		    public:
 		      EdgeMap(const Graph& _g)
+		      explicit EdgeMap(const Graph& _g)
 			: Parent(_g) {}
 		      EdgeMap(const Graph& _g, const _Value& _v)
 			: Parent(_g, _v) {}
 		      EdgeMap& operator=(const EdgeMap& cmap) {
 			return operator=<EdgeMap>(cmap);
+		      }
 		      template <typename CMap>
 		      EdgeMap& operator=(const CMap& cmap) {
 		        Parent::operator=(cmap);
 			return *this;
+		      }
 		    };
 		    // Alteration extension
 		    Edge addEdge(const Node& from, const Node& to) {
 		      Edge edge = Parent::addEdge(from, to);
 		      notifier(Edge()).add(edge);
 		      std::vector<Arc> arcs;
 		      arcs.push_back(Parent::direct(edge, true));
 		      arcs.push_back(Parent::direct(edge, false));
 		      notifier(Arc()).add(arcs);
 		      return edge;
+		    }
 		    void clear() {
 		      notifier(Arc()).clear();
 		      notifier(Edge()).clear();
 		      Parent::clear();
+		    }
 		    void erase(const Edge& edge) {
 		      std::vector<Arc> arcs;
 		      arcs.push_back(Parent::direct(edge, true));
 		      arcs.push_back(Parent::direct(edge, false));
 		      notifier(Arc()).erase(arcs);
 		      notifier(Edge()).erase(edge);
 		      Parent::erase(edge);
+		    }
 		    EdgeSetExtender() {
 		      arc_notifier.setContainer(*this);
 		      edge_notifier.setContainer(*this);
+		    }
 		    ~EdgeSetExtender() {
 		      edge_notifier.clear();
 		      arc_notifier.clear();
+		    }
 		  };
+		}
 		#endif

lemon/bits/graph_extender.h

Show inline comments

@@ -351,401 +351,401 @@
 		      return Parent::maxArcId();
+		    }
 		    int maxId(Edge) const {
 		      return Parent::maxEdgeId();
+		    }
 		    Node fromId(int id, Node) const {
 		      return Parent::nodeFromId(id);
+		    }
 		    Arc fromId(int id, Arc) const {
 		      return Parent::arcFromId(id);
+		    }
 		    Edge fromId(int id, Edge) const {
 		      return Parent::edgeFromId(id);
+		    }
 		    Node oppositeNode(const Node &n, const Edge &e) const {
 		      if( n == Parent::u(e))
 		        return Parent::v(e);
 		      else if( n == Parent::v(e))
 		        return Parent::u(e);
 		      else
 		        return INVALID;
+		    }
 		    Arc oppositeArc(const Arc &arc) const {
 		      return Parent::direct(arc, !Parent::direction(arc));
+		    }
 		    using Parent::direct;
 		    Arc direct(const Edge &edge, const Node &node) const {
 		      return Parent::direct(edge, Parent::u(edge) == node);
+		    }
 		    // Alterable extension
 		    typedef AlterationNotifier<GraphExtender, Node> NodeNotifier;
 		    typedef AlterationNotifier<GraphExtender, Arc> ArcNotifier;
 		    typedef AlterationNotifier<GraphExtender, Edge> EdgeNotifier;
 		  protected:
 		    mutable NodeNotifier node_notifier;
 		    mutable ArcNotifier arc_notifier;
 		    mutable EdgeNotifier edge_notifier;
 		  public:
 		    NodeNotifier& notifier(Node) const {
 		      return node_notifier;
+		    }
 		    ArcNotifier& notifier(Arc) const {
 		      return arc_notifier;
+		    }
 		    EdgeNotifier& notifier(Edge) const {
 		      return edge_notifier;
+		    }
 		    class NodeIt : public Node {
 		      const Graph* _graph;
 		    public:
 		      NodeIt() {}
 		      NodeIt(Invalid i) : Node(i) { }
 		      explicit NodeIt(const Graph& graph) : _graph(&graph) {
 		        _graph->first(static_cast<Node&>(*this));
+		      }
 		      NodeIt(const Graph& graph, const Node& node)
 		        : Node(node), _graph(&graph) {}
 		      NodeIt& operator++() {
 		        _graph->next(*this);
 		        return *this;
+		      }
 		    };
 		    class ArcIt : public Arc {
 		      const Graph* _graph;
 		    public:
 		      ArcIt() { }
 		      ArcIt(Invalid i) : Arc(i) { }
 		      explicit ArcIt(const Graph& graph) : _graph(&graph) {
 		        _graph->first(static_cast<Arc&>(*this));
+		      }
 		      ArcIt(const Graph& graph, const Arc& arc) :
 		        Arc(arc), _graph(&graph) { }
 		      ArcIt& operator++() {
 		        _graph->next(*this);
 		        return *this;
+		      }
 		    };
 		    class OutArcIt : public Arc {
 		      const Graph* _graph;
 		    public:
 		      OutArcIt() { }
 		      OutArcIt(Invalid i) : Arc(i) { }
 		      OutArcIt(const Graph& graph, const Node& node)
 		        : _graph(&graph) {
 		        _graph->firstOut(*this, node);
+		      }
 		      OutArcIt(const Graph& graph, const Arc& arc)
 		        : Arc(arc), _graph(&graph) {}
 		      OutArcIt& operator++() {
 		        _graph->nextOut(*this);
 		        return *this;
+		      }
 		    };
 		    class InArcIt : public Arc {
 		      const Graph* _graph;
 		    public:
 		      InArcIt() { }
 		      InArcIt(Invalid i) : Arc(i) { }
 		      InArcIt(const Graph& graph, const Node& node)
 		        : _graph(&graph) {
 		        _graph->firstIn(*this, node);
+		      }
 		      InArcIt(const Graph& graph, const Arc& arc) :
 		        Arc(arc), _graph(&graph) {}
 		      InArcIt& operator++() {
 		        _graph->nextIn(*this);
 		        return *this;
+		      }
 		    };
 		    class EdgeIt : public Parent::Edge {
 		      const Graph* _graph;
 		    public:
 		      EdgeIt() { }
 		      EdgeIt(Invalid i) : Edge(i) { }
 		      explicit EdgeIt(const Graph& graph) : _graph(&graph) {
 		        _graph->first(static_cast<Edge&>(*this));
+		      }
 		      EdgeIt(const Graph& graph, const Edge& edge) :
 		        Edge(edge), _graph(&graph) { }
 		      EdgeIt& operator++() {
 		        _graph->next(*this);
 		        return *this;
+		      }
 		    };
 		    class IncEdgeIt : public Parent::Edge {
 		      friend class GraphExtender;
 		      const Graph* _graph;
 		      bool _direction;
 		    public:
 		      IncEdgeIt() { }
 		      IncEdgeIt(Invalid i) : Edge(i), _direction(false) { }
 		      IncEdgeIt(const Graph& graph, const Node &node) : _graph(&graph) {
 		        _graph->firstInc(*this, _direction, node);
+		      }
 		      IncEdgeIt(const Graph& graph, const Edge &edge, const Node &node)
 		        : _graph(&graph), Edge(edge) {
 		        _direction = (_graph->source(edge) == node);
+		      }
 		      IncEdgeIt& operator++() {
 		        _graph->nextInc(*this, _direction);
 		        return *this;
+		      }
 		    };
 		    // \brief Base node of the iterator
 		    //
 		    // Returns the base node (ie. the source in this case) of the iterator
 		    Node baseNode(const OutArcIt &arc) const {
 		      return Parent::source(static_cast<const Arc&>(arc));
+		    }
 		    // \brief Running node of the iterator
 		    //
 		    // Returns the running node (ie. the target in this case) of the
 		    // iterator
 		    Node runningNode(const OutArcIt &arc) const {
 		      return Parent::target(static_cast<const Arc&>(arc));
+		    }
 		    // \brief Base node of the iterator
 		    //
 		    // Returns the base node (ie. the target in this case) of the iterator
 		    Node baseNode(const InArcIt &arc) const {
 		      return Parent::target(static_cast<const Arc&>(arc));
+		    }
 		    // \brief Running node of the iterator
 		    //
 		    // Returns the running node (ie. the source in this case) of the
 		    // iterator
 		    Node runningNode(const InArcIt &arc) const {
 		      return Parent::source(static_cast<const Arc&>(arc));
+		    }
 		    // Base node of the iterator
 		    //
 		    // Returns the base node of the iterator
 		    Node baseNode(const IncEdgeIt &edge) const {
 		      return edge._direction ? u(edge) : v(edge);
+		    }
 		    // Running node of the iterator
 		    //
 		    // Returns the running node of the iterator
 		    Node runningNode(const IncEdgeIt &edge) const {
 		      return edge._direction ? v(edge) : u(edge);
+		    }
 		    // Mappable extension
 		    template <typename _Value>
 		    class NodeMap
 		      : public MapExtender<DefaultMap<Graph, Node, _Value> > {
 		      typedef MapExtender<DefaultMap<Graph, Node, _Value> > Parent;
 		    public:
 		      NodeMap(const Graph& graph)
+		      explicit NodeMap(const Graph& graph)
 		        : Parent(graph) {}
 		      NodeMap(const Graph& graph, const _Value& value)
 		        : Parent(graph, value) {}
 		    private:
 		      NodeMap& operator=(const NodeMap& cmap) {
 		        return operator=<NodeMap>(cmap);
+		      }
 		      template <typename CMap>
 		      NodeMap& operator=(const CMap& cmap) {
 		        Parent::operator=(cmap);
 		        return *this;
+		      }
 		    };
 		    template <typename _Value>
 		    class ArcMap
 		      : public MapExtender<DefaultMap<Graph, Arc, _Value> > {
 		      typedef MapExtender<DefaultMap<Graph, Arc, _Value> > Parent;
 		    public:
 		      ArcMap(const Graph& graph)
+		      explicit ArcMap(const Graph& graph)
 		        : Parent(graph) {}
 		      ArcMap(const Graph& graph, const _Value& value)
 		        : Parent(graph, value) {}
 		    private:
 		      ArcMap& operator=(const ArcMap& cmap) {
 		        return operator=<ArcMap>(cmap);
+		      }
 		      template <typename CMap>
 		      ArcMap& operator=(const CMap& cmap) {
 		        Parent::operator=(cmap);
 		        return *this;
+		      }
 		    };
 		    template <typename _Value>
 		    class EdgeMap
 		      : public MapExtender<DefaultMap<Graph, Edge, _Value> > {
 		      typedef MapExtender<DefaultMap<Graph, Edge, _Value> > Parent;
 		    public:
 		      EdgeMap(const Graph& graph)
+		      explicit EdgeMap(const Graph& graph)
 		        : Parent(graph) {}
 		      EdgeMap(const Graph& graph, const _Value& value)
 		        : Parent(graph, value) {}
 		    private:
 		      EdgeMap& operator=(const EdgeMap& cmap) {
 		        return operator=<EdgeMap>(cmap);
+		      }
 		      template <typename CMap>
 		      EdgeMap& operator=(const CMap& cmap) {
 		        Parent::operator=(cmap);
 		        return *this;
+		      }
 		    };
 		    // Alteration extension
 		    Node addNode() {
 		      Node node = Parent::addNode();
 		      notifier(Node()).add(node);
 		      return node;
+		    }
 		    Edge addEdge(const Node& from, const Node& to) {
 		      Edge edge = Parent::addEdge(from, to);
 		      notifier(Edge()).add(edge);
 		      std::vector<Arc> ev;
 		      ev.push_back(Parent::direct(edge, true));
 		      ev.push_back(Parent::direct(edge, false));
 		      notifier(Arc()).add(ev);
 		      return edge;
+		    }
 		    void clear() {
 		      notifier(Arc()).clear();
 		      notifier(Edge()).clear();
 		      notifier(Node()).clear();
 		      Parent::clear();
+		    }
 		    template <typename Graph, typename NodeRefMap, typename EdgeRefMap>
 		    void build(const Graph& graph, NodeRefMap& nodeRef,
 		               EdgeRefMap& edgeRef) {
 		      Parent::build(graph, nodeRef, edgeRef);
 		      notifier(Node()).build();
 		      notifier(Edge()).build();
 		      notifier(Arc()).build();
+		    }
 		    void erase(const Node& node) {
 		      Arc arc;
 		      Parent::firstOut(arc, node);
 		      while (arc != INVALID ) {
 		        erase(arc);
 		        Parent::firstOut(arc, node);
+		      }
 		      Parent::firstIn(arc, node);
 		      while (arc != INVALID ) {
 		        erase(arc);
 		        Parent::firstIn(arc, node);
+		      }
 		      notifier(Node()).erase(node);
 		      Parent::erase(node);
+		    }
 		    void erase(const Edge& edge) {
 		      std::vector<Arc> av;
 		      av.push_back(Parent::direct(edge, true));
 		      av.push_back(Parent::direct(edge, false));
 		      notifier(Arc()).erase(av);
 		      notifier(Edge()).erase(edge);
 		      Parent::erase(edge);
+		    }
 		    GraphExtender() {
 		      node_notifier.setContainer(*this);
 		      arc_notifier.setContainer(*this);
 		      edge_notifier.setContainer(*this);
+		    }
 		    ~GraphExtender() {
 		      edge_notifier.clear();
 		      arc_notifier.clear();
 		      node_notifier.clear();
+		    }
 		  };
+		}
 		#endif

lemon/circulation.h

Show inline comments

 		/* -*- mode: C++; indent-tabs-mode: nil; -*-
+		 *
 		 * This file is a part of LEMON, a generic C++ optimization library.
+		 *
 		 * 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_CIRCULATION_H
 		#define LEMON_CIRCULATION_H
 		#include <lemon/tolerance.h>
 		#include <lemon/elevator.h>
 		#include <limits>
 		///\ingroup max_flow
 		///\file
 		///\brief Push-relabel algorithm for finding a feasible circulation.
 		///
 		namespace lemon {
 		  /// \brief Default traits class of Circulation class.
 		  ///
 		  /// Default traits class of Circulation class.
 		  ///
 		  /// \tparam GR Type of the digraph the algorithm runs on.
 		  /// \tparam LM The type of the lower bound map.
 		  /// \tparam UM The type of the upper bound (capacity) map.
 		  /// \tparam SM The type of the supply map.
 		  template <typename GR, typename LM,
 		            typename UM, typename SM>
 		  struct CirculationDefaultTraits {
 		    /// \brief The type of the digraph the algorithm runs on.
 		    typedef GR Digraph;
 		    /// \brief The type of the lower bound map.
 		    ///
 		    /// The type of the map that stores the lower bounds on the arcs.
 		    /// It must conform to the \ref concepts::ReadMap "ReadMap" concept.
 		    typedef LM LowerMap;
 		    /// \brief The type of the upper bound (capacity) map.
 		    ///
 		    /// The type of the map that stores the upper bounds (capacities)
 		    /// on the arcs.
 		    /// It must conform to the \ref concepts::ReadMap "ReadMap" concept.
 		    typedef UM UpperMap;
 		    /// \brief The type of supply map.
 		    ///
 		    /// The type of the map that stores the signed supply values of the
 		    /// nodes.
 		    /// It must conform to the \ref concepts::ReadMap "ReadMap" concept.
 		    typedef SM SupplyMap;
 		    /// \brief The type of the flow and supply values.
 		    typedef typename SupplyMap::Value Value;
 		    /// \brief The type of the map that stores the flow values.
 		    ///
 		    /// The type of the map that stores the flow values.
 		    /// It must conform to the \ref concepts::ReadWriteMap "ReadWriteMap"
 		    /// concept.
 		#ifdef DOXYGEN
 		    typedef GR::ArcMap<Value> FlowMap;
 		#else
 		    typedef typename Digraph::template ArcMap<Value> FlowMap;
 		#endif
 		    /// \brief Instantiates a FlowMap.
 		    ///
 		    /// This function instantiates a \ref FlowMap.
 		    /// \param digraph The digraph for which we would like to define
 		    /// the flow map.
 		    static FlowMap* createFlowMap(const Digraph& digraph) {
 		      return new FlowMap(digraph);
+		    }
 		    /// \brief The elevator type used by the algorithm.
 		    ///
 		    /// The elevator type used by the algorithm.
 		    ///
 		    /// \sa Elevator
 		    /// \sa LinkedElevator
 		    /// \sa Elevator, LinkedElevator
 		#ifdef DOXYGEN
 		    typedef lemon::Elevator<GR, GR::Node> Elevator;
 		#else
 		    typedef lemon::Elevator<Digraph, typename Digraph::Node> Elevator;
 		#endif
 		    /// \brief Instantiates an Elevator.
 		    ///
 		    /// This function instantiates an \ref Elevator.
 		    /// \param digraph The digraph for which we would like to define
 		    /// the elevator.
 		    /// \param max_level The maximum level of the elevator.
 		    static Elevator* createElevator(const Digraph& digraph, int max_level) {
 		      return new Elevator(digraph, max_level);
+		    }
 		    /// \brief The tolerance used by the algorithm
 		    ///
 		    /// The tolerance used by the algorithm to handle inexact computation.
 		    typedef lemon::Tolerance<Value> Tolerance;
 		  };
 		  /**
 		     \brief Push-relabel algorithm for the network circulation problem.
 		     \ingroup max_flow
 		     This class implements a push-relabel algorithm for the \e network
 		     \e circulation problem.
 		     It is to find a feasible circulation when lower and upper bounds
 		     are given for the flow values on the arcs and lower bounds are
 		     given for the difference between the outgoing and incoming flow
 		     at the nodes.
 		     The exact formulation of this problem is the following.
 		     Let \f$G=(V,A)\f$ be a digraph, \f$lower: A\rightarrow\mathbf{R}\f$
 		     \f$upper: A\rightarrow\mathbf{R}\cup\{\infty\}\f$ denote the lower and
 		     upper bounds on the arcs, for which \f$lower(uv) \leq upper(uv)\f$
 		     holds for all \f$uv\in A\f$, and \f$sup: V\rightarrow\mathbf{R}\f$
 		     denotes the signed supply values of the nodes.
 		     If \f$sup(u)>0\f$, then \f$u\f$ is a supply node with \f$sup(u)\f$
 		     supply, if \f$sup(u)<0\f$, then \f$u\f$ is a demand node with
 		     \f$-sup(u)\f$ demand.
 		     A feasible circulation is an \f$f: A\rightarrow\mathbf{R}\f$
 		     solution of the following problem.
 		     \f[ \sum_{uv\in A} f(uv) - \sum_{vu\in A} f(vu)
 		     \geq sup(u) \quad \forall u\in V, \f]
 		     \f[ lower(uv) \leq f(uv) \leq upper(uv) \quad \forall uv\in A. \f]
 		     The sum of the supply values, i.e. \f$\sum_{u\in V} sup(u)\f$ must be
 		     zero or negative in order to have a feasible solution (since the sum
 		     of the expressions on the left-hand side of the inequalities is zero).
 		     It means that the total demand must be greater or equal to the total
 		     supply and all the supplies have to be carried out from the supply nodes,
 		     but there could be demands that are not satisfied.
 		     If \f$\sum_{u\in V} sup(u)\f$ is zero, then all the supply/demand
 		     constraints have to be satisfied with equality, i.e. all demands
 		     have to be satisfied and all supplies have to be used.
 		     If you need the opposite inequalities in the supply/demand constraints
 		     (i.e. the total demand is less than the total supply and all the demands
 		     have to be satisfied while there could be supplies that are not used),
 		     then you could easily transform the problem to the above form by reversing
 		     the direction of the arcs and taking the negative of the supply values
 		     (e.g. using \ref ReverseDigraph and \ref NegMap adaptors).
 		     This algorithm either calculates a feasible circulation, or provides
 		     a \ref barrier() "barrier", which prooves that a feasible soultion
 		     cannot exist.
 		     Note that this algorithm also provides a feasible solution for the
 		     \ref min_cost_flow "minimum cost flow problem".
 		     \tparam GR The type of the digraph the algorithm runs on.
 		     \tparam LM The type of the lower bound map. The default
 		     map type is \ref concepts::Digraph::ArcMap "GR::ArcMap<int>".
 		     \tparam UM The type of the upper bound (capacity) map.
 		     The default map type is \c LM.
 		     \tparam SM The type of the supply map. The default map type is
 		     \ref concepts::Digraph::NodeMap "GR::NodeMap<UM::Value>".
 		  */
 		#ifdef DOXYGEN
 		template< typename GR,
 		          typename LM,
 		          typename UM,
 		          typename SM,
 		          typename TR >
 		#else
 		template< typename GR,
 		          typename LM = typename GR::template ArcMap<int>,
 		          typename UM = LM,
 		          typename SM = typename GR::template NodeMap<typename UM::Value>,
 		          typename TR = CirculationDefaultTraits<GR, LM, UM, SM> >
 		#endif
 		  class Circulation {
 		  public:
 		    ///The \ref CirculationDefaultTraits "traits class" of the algorithm.
 		    typedef TR Traits;
 		    ///The type of the digraph the algorithm runs on.
 		    typedef typename Traits::Digraph Digraph;
 		    ///The type of the flow and supply values.
 		    typedef typename Traits::Value Value;
 		    ///The type of the lower bound map.
 		    typedef typename Traits::LowerMap LowerMap;
 		    ///The type of the upper bound (capacity) map.
 		    typedef typename Traits::UpperMap UpperMap;
 		    ///The type of the supply map.
 		    typedef typename Traits::SupplyMap SupplyMap;
 		    ///The type of the flow map.
 		    typedef typename Traits::FlowMap FlowMap;
 		    ///The type of the elevator.
 		    typedef typename Traits::Elevator Elevator;
 		    ///The type of the tolerance.
 		    typedef typename Traits::Tolerance Tolerance;
 		  private:
 		    TEMPLATE_DIGRAPH_TYPEDEFS(Digraph);
 		    const Digraph &_g;
 		    int _node_num;
 		    const LowerMap *_lo;
 		    const UpperMap *_up;
 		    const SupplyMap *_supply;
 		    FlowMap *_flow;
 		    bool _local_flow;
 		    Elevator* _level;
 		    bool _local_level;
 		    typedef typename Digraph::template NodeMap<Value> ExcessMap;
 		    ExcessMap* _excess;
 		    Tolerance _tol;
 		    int _el;
 		  public:
 		    typedef Circulation Create;
 		    ///\name Named Template Parameters
 		    ///@{
 		    template <typename T>
 		    struct SetFlowMapTraits : public Traits {
 		      typedef T FlowMap;
 		      static FlowMap *createFlowMap(const Digraph&) {
 		        LEMON_ASSERT(false, "FlowMap is not initialized");
 		        return 0; // ignore warnings
+		      }
 		    };
 		    /// \brief \ref named-templ-param "Named parameter" for setting
 		    /// FlowMap type
 		    ///
 		    /// \ref named-templ-param "Named parameter" for setting FlowMap
 		    /// type.
 		    template <typename T>
 		    struct SetFlowMap
 		      : public Circulation<Digraph, LowerMap, UpperMap, SupplyMap,
 		                           SetFlowMapTraits<T> > {
 		      typedef Circulation<Digraph, LowerMap, UpperMap, SupplyMap,
 		                          SetFlowMapTraits<T> > Create;
 		    };
 		    template <typename T>
 		    struct SetElevatorTraits : public Traits {
 		      typedef T Elevator;
 		      static Elevator *createElevator(const Digraph&, int) {
 		        LEMON_ASSERT(false, "Elevator is not initialized");
 		        return 0; // ignore warnings
+		      }
 		    };
 		    /// \brief \ref named-templ-param "Named parameter" for setting
 		    /// Elevator type
 		    ///
 		    /// \ref named-templ-param "Named parameter" for setting Elevator
 		    /// type. If this named parameter is used, then an external
 		    /// elevator object must be passed to the algorithm using the
 		    /// \ref elevator(Elevator&) "elevator()" function before calling
 		    /// \ref run() or \ref init().
 		    /// \sa SetStandardElevator
 		    template <typename T>
 		    struct SetElevator
 		      : public Circulation<Digraph, LowerMap, UpperMap, SupplyMap,
 		                           SetElevatorTraits<T> > {
 		      typedef Circulation<Digraph, LowerMap, UpperMap, SupplyMap,
 		                          SetElevatorTraits<T> > Create;
 		    };
 		    template <typename T>
 		    struct SetStandardElevatorTraits : public Traits {
 		      typedef T Elevator;
 		      static Elevator *createElevator(const Digraph& digraph, int max_level) {
 		        return new Elevator(digraph, max_level);
+		      }
 		    };
 		    /// \brief \ref named-templ-param "Named parameter" for setting
 		    /// Elevator type with automatic allocation
 		    ///
 		    /// \ref named-templ-param "Named parameter" for setting Elevator
 		    /// type with automatic allocation.
 		    /// The Elevator should have standard constructor interface to be
 		    /// able to automatically created by the algorithm (i.e. the
 		    /// digraph and the maximum level should be passed to it).
 		    /// However an external elevator object could also be passed to the
 		    /// algorithm with the \ref elevator(Elevator&) "elevator()" function
 		    /// before calling \ref run() or \ref init().
 		    /// \sa SetElevator
 		    template <typename T>
 		    struct SetStandardElevator
 		      : public Circulation<Digraph, LowerMap, UpperMap, SupplyMap,
 		                       SetStandardElevatorTraits<T> > {
 		      typedef Circulation<Digraph, LowerMap, UpperMap, SupplyMap,
 		                      SetStandardElevatorTraits<T> > Create;
 		    };
 		    /// @}
 		  protected:
 		    Circulation() {}
 		  public:
 		    /// Constructor.
 		    /// The constructor of the class.
 		    ///
 		    /// \param graph The digraph the algorithm runs on.
 		    /// \param lower The lower bounds for the flow values on the arcs.
 		    /// \param upper The upper bounds (capacities) for the flow values
 		    /// on the arcs.
 		    /// \param supply The signed supply values of the nodes.
 		    Circulation(const Digraph &graph, const LowerMap &lower,
 		                const UpperMap &upper, const SupplyMap &supply)
 		      : _g(graph), _lo(&lower), _up(&upper), _supply(&supply),
 		        _flow(NULL), _local_flow(false), _level(NULL), _local_level(false),
 		        _excess(NULL) {}
 		    /// Destructor.
 		    ~Circulation() {
 		      destroyStructures();
+		    }
 		  private:
 		    bool checkBoundMaps() {
 		      for (ArcIt e(_g);e!=INVALID;++e) {
 		        if (_tol.less((*_up)[e], (*_lo)[e])) return false;
+		      }
 		      return true;
+		    }
 		    void createStructures() {
 		      _node_num = _el = countNodes(_g);
 		      if (!_flow) {
 		        _flow = Traits::createFlowMap(_g);
 		        _local_flow = true;
+		      }
 		      if (!_level) {
 		        _level = Traits::createElevator(_g, _node_num);
 		        _local_level = true;
+		      }
 		      if (!_excess) {
 		        _excess = new ExcessMap(_g);
+		      }
+		    }
 		    void destroyStructures() {
 		      if (_local_flow) {
 		        delete _flow;
+		      }
 		      if (_local_level) {
 		        delete _level;
+		      }
 		      if (_excess) {
 		        delete _excess;
+		      }
+		    }
 		  public:
 		    /// Sets the lower bound map.
 		    /// Sets the lower bound map.
 		    /// \return <tt>(*this)</tt>
 		    Circulation& lowerMap(const LowerMap& map) {
 		      _lo = &map;
 		      return *this;
+		    }
 		    /// Sets the upper bound (capacity) map.
 		    /// Sets the upper bound (capacity) map.
 		    /// \return <tt>(*this)</tt>
 		    Circulation& upperMap(const UpperMap& map) {
 		      _up = &map;
 		      return *this;
+		    }
 		    /// Sets the supply map.
 		    /// Sets the supply map.
 		    /// \return <tt>(*this)</tt>
 		    Circulation& supplyMap(const SupplyMap& map) {
 		      _supply = &map;
 		      return *this;
+		    }
 		    /// \brief Sets the flow map.
 		    ///
 		    /// Sets the flow map.
 		    /// If you don't use this function before calling \ref run() or
 		    /// \ref init(), an instance will be allocated automatically.
 		    /// The destructor deallocates this automatically allocated map,
 		    /// of course.
 		    /// \return <tt>(*this)</tt>
 		    Circulation& flowMap(FlowMap& map) {
 		      if (_local_flow) {
 		        delete _flow;
 		        _local_flow = false;
+		      }
 		      _flow = &map;
 		      return *this;
+		    }
 		    /// \brief Sets the elevator used by algorithm.
 		    ///
 		    /// Sets the elevator used by algorithm.
 		    /// If you don't use this function before calling \ref run() or
 		    /// \ref init(), an instance will be allocated automatically.
 		    /// The destructor deallocates this automatically allocated elevator,
 		    /// of course.
 		    /// \return <tt>(*this)</tt>
 		    Circulation& elevator(Elevator& elevator) {
 		      if (_local_level) {
 		        delete _level;
 		        _local_level = false;
+		      }
 		      _level = &elevator;
 		      return *this;
+		    }
 		    /// \brief Returns a const reference to the elevator.
 		    ///
 		    /// Returns a const reference to the elevator.
 		    ///
 		    /// \pre Either \ref run() or \ref init() must be called before
 		    /// using this function.
 		    const Elevator& elevator() const {
 		      return *_level;
+		    }
 		    /// \brief Sets the tolerance used by algorithm.
+		    /// \brief Sets the tolerance used by the algorithm.
 		    ///
 		    /// Sets the tolerance used by algorithm.
 		    Circulation& tolerance(const Tolerance& tolerance) const {
 		    /// Sets the tolerance object used by the algorithm.
 		    /// \return <tt>(*this)</tt>
 		    Circulation& tolerance(const Tolerance& tolerance) {
 		      _tol = tolerance;
 		      return *this;
+		    }
 		    /// \brief Returns a const reference to the tolerance.
 		    ///
-		    /// Returns a const reference to the tolerance.
+		    /// Returns a const reference to the tolerance object used by
 		    /// the algorithm.
 		    const Tolerance& tolerance() const {
-		      return tolerance;
+		      return _tol;
+		    }
 		    /// \name Execution Control
 		    /// The simplest way to execute the algorithm is to call \ref run().\n
 		    /// If you need more control on the initial solution or the execution,
 		    /// first you have to call one of the \ref init() functions, then
 		    /// If you need better control on the initial solution or the execution,
 		    /// you have to call one of the \ref init() functions first, then
 		    /// the \ref start() function.
 		    ///@{
 		    /// Initializes the internal data structures.
 		    /// Initializes the internal data structures and sets all flow values
 		    /// to the lower bound.
 		    void init()
+		    {
 		      LEMON_DEBUG(checkBoundMaps(),
 		        "Upper bounds must be greater or equal to the lower bounds");
 		      createStructures();
 		      for(NodeIt n(_g);n!=INVALID;++n) {
 		        (*_excess)[n] = (*_supply)[n];
+		      }
 		      for (ArcIt e(_g);e!=INVALID;++e) {
 		        _flow->set(e, (*_lo)[e]);
 		        (*_excess)[_g.target(e)] += (*_flow)[e];
 		        (*_excess)[_g.source(e)] -= (*_flow)[e];
+		      }
 		      // global relabeling tested, but in general case it provides
 		      // worse performance for random digraphs
 		      _level->initStart();
 		      for(NodeIt n(_g);n!=INVALID;++n)
 		        _level->initAddItem(n);
 		      _level->initFinish();
 		      for(NodeIt n(_g);n!=INVALID;++n)
 		        if(_tol.positive((*_excess)[n]))
 		          _level->activate(n);
+		    }
 		    /// Initializes the internal data structures using a greedy approach.
 		    /// Initializes the internal data structures using a greedy approach
 		    /// to construct the initial solution.
 		    void greedyInit()
+		    {
 		      LEMON_DEBUG(checkBoundMaps(),
 		        "Upper bounds must be greater or equal to the lower bounds");
 		      createStructures();
 		      for(NodeIt n(_g);n!=INVALID;++n) {
 		        (*_excess)[n] = (*_supply)[n];
+		      }
 		      for (ArcIt e(_g);e!=INVALID;++e) {
 		        if (!_tol.less(-(*_excess)[_g.target(e)], (*_up)[e])) {
 		          _flow->set(e, (*_up)[e]);
 		          (*_excess)[_g.target(e)] += (*_up)[e];
 		          (*_excess)[_g.source(e)] -= (*_up)[e];
 		        } else if (_tol.less(-(*_excess)[_g.target(e)], (*_lo)[e])) {
 		          _flow->set(e, (*_lo)[e]);
 		          (*_excess)[_g.target(e)] += (*_lo)[e];
 		          (*_excess)[_g.source(e)] -= (*_lo)[e];
 		        } else {
 		          Value fc = -(*_excess)[_g.target(e)];
 		          _flow->set(e, fc);
 		          (*_excess)[_g.target(e)] = 0;
 		          (*_excess)[_g.source(e)] -= fc;
+		        }
+		      }
 		      _level->initStart();
 		      for(NodeIt n(_g);n!=INVALID;++n)
 		        _level->initAddItem(n);
 		      _level->initFinish();
 		      for(NodeIt n(_g);n!=INVALID;++n)
 		        if(_tol.positive((*_excess)[n]))
 		          _level->activate(n);
+		    }
 		    ///Executes the algorithm
 		    ///This function executes the algorithm.
 		    ///
 		    ///\return \c true if a feasible circulation is found.
 		    ///
 		    ///\sa barrier()
 		    ///\sa barrierMap()
 		    bool start()
+		    {
 		      Node act;
 		      Node bact=INVALID;
 		      Node last_activated=INVALID;
 		      while((act=_level->highestActive())!=INVALID) {
 		        int actlevel=(*_level)[act];
 		        int mlevel=_node_num;
 		        Value exc=(*_excess)[act];
 		        for(OutArcIt e(_g,act);e!=INVALID; ++e) {
 		          Node v = _g.target(e);
 		          Value fc=(*_up)[e]-(*_flow)[e];
 		          if(!_tol.positive(fc)) continue;
 		          if((*_level)[v]<actlevel) {
 		            if(!_tol.less(fc, exc)) {
 		              _flow->set(e, (*_flow)[e] + exc);
 		              (*_excess)[v] += exc;
 		              if(!_level->active(v) && _tol.positive((*_excess)[v]))
 		                _level->activate(v);
 		              (*_excess)[act] = 0;
 		              _level->deactivate(act);
 		              goto next_l;
+		            }
 		            else {
 		              _flow->set(e, (*_up)[e]);
 		              (*_excess)[v] += fc;
 		              if(!_level->active(v) && _tol.positive((*_excess)[v]))
 		                _level->activate(v);
 		              exc-=fc;
+		            }
+		          }
 		          else if((*_level)[v]<mlevel) mlevel=(*_level)[v];
+		        }
 		        for(InArcIt e(_g,act);e!=INVALID; ++e) {
 		          Node v = _g.source(e);
 		          Value fc=(*_flow)[e]-(*_lo)[e];
 		          if(!_tol.positive(fc)) continue;
 		          if((*_level)[v]<actlevel) {
 		            if(!_tol.less(fc, exc)) {
 		              _flow->set(e, (*_flow)[e] - exc);
 		              (*_excess)[v] += exc;
 		              if(!_level->active(v) && _tol.positive((*_excess)[v]))
 		                _level->activate(v);
 		              (*_excess)[act] = 0;
 		              _level->deactivate(act);
 		              goto next_l;
+		            }
 		            else {
 		              _flow->set(e, (*_lo)[e]);
 		              (*_excess)[v] += fc;
 		              if(!_level->active(v) && _tol.positive((*_excess)[v]))
 		                _level->activate(v);
 		              exc-=fc;
+		            }
+		          }
 		          else if((*_level)[v]<mlevel) mlevel=(*_level)[v];
+		        }
 		        (*_excess)[act] = exc;
 		        if(!_tol.positive(exc)) _level->deactivate(act);
 		        else if(mlevel==_node_num) {
 		          _level->liftHighestActiveToTop();
 		          _el = _node_num;
 		          return false;
+		        }
 		        else {
 		          _level->liftHighestActive(mlevel+1);
 		          if(_level->onLevel(actlevel)==0) {
 		            _el = actlevel;
 		            return false;
+		          }
+		        }
 		      next_l:
+		        ;
+		      }
 		      return true;
+		    }
 		    /// Runs the algorithm.
 		    /// This function runs the algorithm.
 		    ///
 		    /// \return \c true if a feasible circulation is found.
 		    ///
 		    /// \note Apart from the return value, c.run() is just a shortcut of
 		    /// the following code.
 		    /// \code
 		    ///   c.greedyInit();
 		    ///   c.start();
 		    /// \endcode
 		    bool run() {
 		      greedyInit();
 		      return start();
+		    }
 		    /// @}
 		    /// \name Query Functions
 		    /// The results of the circulation algorithm can be obtained using
 		    /// these functions.\n
 		    /// Either \ref run() or \ref start() should be called before
 		    /// using them.
 		    ///@{
 		    /// \brief Returns the flow value on the given arc.
 		    ///
 		    /// Returns the flow value on the given arc.
 		    ///
 		    /// \pre Either \ref run() or \ref init() must be called before
 		    /// using this function.
 		    Value flow(const Arc& arc) const {
 		      return (*_flow)[arc];
+		    }
 		    /// \brief Returns a const reference to the flow map.
 		    ///
 		    /// Returns a const reference to the arc map storing the found flow.
 		    ///
 		    /// \pre Either \ref run() or \ref init() must be called before
 		    /// using this function.
 		    const FlowMap& flowMap() const {
 		      return *_flow;
+		    }
 		    /**
 		       \brief Returns \c true if the given node is in a barrier.
 		       Barrier is a set \e B of nodes for which
 		       \f[ \sum_{uv\in A: u\in B} upper(uv) -
 		           \sum_{uv\in A: v\in B} lower(uv) < \sum_{v\in B} sup(v) \f]
 		       holds. The existence of a set with this property prooves that a
 		       feasible circualtion cannot exist.
 		       This function returns \c true if the given node is in the found
 		       barrier. If a feasible circulation is found, the function
 		       gives back \c false for every node.
 		       \pre Either \ref run() or \ref init() must be called before
 		       using this function.
 		       \sa barrierMap()
 		       \sa checkBarrier()
 		    */
 		    bool barrier(const Node& node) const
+		    {
 		      return (*_level)[node] >= _el;
+		    }
 		    /// \brief Gives back a barrier.
 		    ///
 		    /// This function sets \c bar to the characteristic vector of the
 		    /// found barrier. \c bar should be a \ref concepts::WriteMap "writable"
 		    /// node map with \c bool (or convertible) value type.
 		    ///
 		    /// If a feasible circulation is found, the function gives back an
 		    /// empty set, so \c bar[v] will be \c false for all nodes \c v.
 		    ///
 		    /// \note This function calls \ref barrier() for each node,
 		    /// so it runs in O(n) time.
 		    ///
 		    /// \pre Either \ref run() or \ref init() must be called before
 		    /// using this function.
 		    ///
 		    /// \sa barrier()
 		    /// \sa checkBarrier()
 		    template<class BarrierMap>

lemon/concepts/heap.h

Show inline comments

 		/* -*- mode: C++; indent-tabs-mode: nil; -*-
+		 *
 		 * This file is a part of LEMON, a generic C++ optimization library.
+		 *
 		 * 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_CONCEPTS_HEAP_H
 		#define LEMON_CONCEPTS_HEAP_H
 		///\ingroup concept
 		///\file
 		///\brief The concept of heaps.
 		#ifndef LEMON_CONCEPTS_HEAP_H
 		#define LEMON_CONCEPTS_HEAP_H
 		#include <lemon/core.h>
 		#include <lemon/concept_check.h>
 		namespace lemon {
 		  namespace concepts {
 		    /// \addtogroup concept
 		    /// @{
 		    /// \brief The heap concept.
 		    ///
 		    /// Concept class describing the main interface of heaps. 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. In a heap one can change the priority of an
-		    /// item, add or erase an item, etc.
+		    /// This concept class describes the main interface of heaps.
 		    /// The various \ref heaps "heap structures" are efficient
 		    /// implementations of the abstract data type \e priority \e queue.
 		    /// They store items with specified values called \e priorities
 		    /// in such a way that finding and removing the item with minimum
 		    /// priority are efficient. The basic operations are adding and
 		    /// erasing items, changing the priority of an item, etc.
 		    ///
 		    /// \tparam PR Type of the priority of the items.
 		    /// \tparam IM A read and writable item map with int values, used
 		    /// Heaps are crucial in several algorithms, such as Dijkstra and Prim.
 		    /// Any class that conforms to this concept can be used easily in such
 		    /// algorithms.
 		    ///
 		    /// \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 Comp A functor class for the ordering of the priorities.
+		    /// \tparam CMP A functor class for comparing the priorities.
 		    /// The default is \c std::less<PR>.
 		#ifdef DOXYGEN
-		    template <typename PR, typename IM, typename Comp = std::less<PR> >
+		    template <typename PR, typename IM, typename CMP>
 		#else
 		    template <typename PR, typename IM>
+		    template <typename PR, typename IM, typename CMP = std::less<PR> >
 		#endif
 		    class Heap {
 		    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;
 		      /// \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 later two are indifferent
 		      /// from the point of view of the heap, but may be useful for
-		      /// the user.
+		      /// "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. The "in heap" state constant.
 		        PRE_HEAP = -1,  ///< = -1. The "pre heap" state constant.
 		        POST_HEAP = -2  ///< = -2. The "post heap" state constant.
 		        PRE_HEAP = -1,  ///< = -1. The "pre-heap" state constant.
 		        POST_HEAP = -2  ///< = -2. The "post-heap" state constant.
 		      };
-		      /// \brief The constructor.
+		      /// \brief Constructor.
 		      ///
-		      /// The constructor.
+		      /// Constructor.
 		      /// \param map A map that assigns \c int values to keys of type
 		      /// \c Item. It is used internally by the heap implementations to
 		      /// handle the cross references. The assigned value must be
-		      /// \c PRE_HEAP (<tt>-1</tt>) for every item.
+		      /// \c PRE_HEAP (<tt>-1</tt>) for each item.
 		      explicit Heap(ItemIntMap &map) {}
 		      /// \brief Constructor.
 		      ///
 		      /// Constructor.
 		      /// \param map A map that assigns \c int values to keys of type
 		      /// \c Item. It is used internally by the heap implementations 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.
 		      explicit Heap(ItemIntMap &map, const CMP &comp) {}
 		      /// \brief The number of items stored in the heap.
 		      ///
-		      /// Returns the number of items stored in the heap.
+		      /// This function returns the number of items stored in the heap.
 		      int size() const { return 0; }
-		      /// \brief Checks if the heap is empty.
+		      /// \brief Check if the heap is empty.
 		      ///
-		      /// Returns \c true if the heap is empty.
+		      /// This function returns \c true if the heap is empty.
 		      bool empty() const { return false; }
-		      /// \brief Makes the heap empty.
+		      /// \brief Make the heap empty.
 		      ///
 		      /// Makes the heap empty.
 		      void 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() {}
-		      /// \brief Inserts an item into the heap with the given priority.
+		      /// \brief Insert an item into the heap with the given priority.
 		      ///
-		      /// Inserts the given item into the heap with the given priority.
+		      /// 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) {}
-		      /// \brief Returns the item having minimum priority.
+		      /// \brief Return the item having minimum priority.
 		      ///
-		      /// Returns the item having minimum priority.
+		      /// This function returns the item having minimum priority.
 		      /// \pre The heap must be non-empty.
 		      Item top() const {}
 		      /// \brief The minimum priority.
 		      ///
-		      /// Returns the minimum priority.
+		      /// This function returns the minimum priority.
 		      /// \pre The heap must be non-empty.
 		      Prio prio() const {}
-		      /// \brief Removes the item having minimum priority.
+		      /// \brief Remove the item having minimum priority.
 		      ///
-		      /// Removes the item having minimum priority.
+		      /// This function removes the item having minimum priority.
 		      /// \pre The heap must be non-empty.
 		      void pop() {}
-		      /// \brief Removes an item from the heap.
+		      /// \brief Remove the given item from the heap.
 		      ///
-		      /// Removes the given item from the heap if it is already stored.
+		      /// 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) {}
-		      /// \brief The priority of an item.
+		      /// \brief The priority of the given item.
 		      ///
-		      /// Returns the priority of the given item.
+		      /// This function returns the priority of the given item.
 		      /// \param i The item.
-		      /// \pre \c i must be in the heap.
+		      /// \pre \e i must be in the heap.
 		      Prio operator[](const Item &i) const {}
-		      /// \brief Sets the priority of an item or inserts it, if it is
+		      /// \brief Set the priority of an item or insert it, if it is
 		      /// not stored in the heap.
 		      ///
 		      /// This method sets the priority of the given item if it is
 		      /// already stored in the heap.
 		      /// Otherwise it inserts the given item with the given priority.
 		      /// 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) {}
-		      /// \brief Decreases the priority of an item to the given value.
+		      /// \brief Decrease the priority of an item to the given value.
 		      ///
-		      /// Decreases the priority of an item to the given value.
+		      /// This function decreases the priority of an item to the given value.
 		      /// \param i The item.
 		      /// \param p The priority.
-		      /// \pre \c i must be stored in the heap with priority at least \c p.
+		      /// \pre \e i must be stored in the heap with priority at least \e p.
 		      void decrease(const Item &i, const Prio &p) {}
-		      /// \brief Increases the priority of an item to the given value.
+		      /// \brief Increase the priority of an item to the given value.
 		      ///
-		      /// Increases the priority of an item to the given value.
+		      /// This function increases the priority of an item to the given value.
 		      /// \param i The item.
 		      /// \param p The priority.
-		      /// \pre \c i must be stored in the heap with priority at most \c p.
+		      /// \pre \e i must be stored in the heap with priority at most \e p.
 		      void increase(const Item &i, const Prio &p) {}
 		      /// \brief Returns if an item is in, has already been in, or has
 		      /// never been in the heap.
 		      /// \brief Return the state of an item.
 		      ///
 		      /// 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 {}
-		      /// \brief Sets the state of an item in the heap.
+		      /// \brief Set the state of an item in the heap.
 		      ///
 		      /// 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 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) {}
 		      template <typename _Heap>
 		      struct Constraints {
 		      public:
 		        void constraints() {
 		          typedef typename _Heap::Item OwnItem;
 		          typedef typename _Heap::Prio OwnPrio;
 		          typedef typename _Heap::State OwnState;
 		          Item item;
 		          Prio prio;
 		          item=Item();
 		          prio=Prio();
 		          ignore_unused_variable_warning(item);
 		          ignore_unused_variable_warning(prio);
 		          OwnItem own_item;
 		          OwnPrio own_prio;
 		          OwnState own_state;
 		          own_item=Item();
 		          own_prio=Prio();
 		          ignore_unused_variable_warning(own_item);
 		          ignore_unused_variable_warning(own_prio);
 		          ignore_unused_variable_warning(own_state);
 		          _Heap heap1(map);
 		          _Heap heap2 = heap1;
 		          ignore_unused_variable_warning(heap1);
 		          ignore_unused_variable_warning(heap2);
 		          int s = heap.size();
 		          ignore_unused_variable_warning(s);
 		          bool e = heap.empty();
 		          ignore_unused_variable_warning(e);
 		          prio = heap.prio();
 		          item = heap.top();
 		          prio = heap[item];
 		          own_prio = heap.prio();
 		          own_item = heap.top();
 		          own_prio = heap[own_item];
 		          heap.push(item, prio);
 		          heap.push(own_item, own_prio);
 		          heap.pop();
 		          heap.set(item, prio);
 		          heap.decrease(item, prio);
 		          heap.increase(item, prio);
 		          heap.set(own_item, own_prio);
 		          heap.decrease(own_item, own_prio);
 		          heap.increase(own_item, own_prio);
 		          heap.erase(item);
 		          heap.erase(own_item);
 		          heap.clear();
 		          own_state = heap.state(own_item);
 		          heap.state(own_item, own_state);
 		          own_state = _Heap::PRE_HEAP;
 		          own_state = _Heap::IN_HEAP;
 		          own_state = _Heap::POST_HEAP;
+		        }
 		        _Heap& heap;
 		        ItemIntMap& map;
 		      };
 		    };
 		    /// @}
 		  } // namespace lemon
+		}
 		#endif

lemon/dfs.h

Show inline comments

@@ -159,514 +159,514 @@
 		    //Pointer to the underlying digraph.
 		    const Digraph *G;
 		    //Pointer to the map of predecessor arcs.
 		    PredMap *_pred;
 		    //Indicates if _pred is locally allocated (true) or not.
 		    bool local_pred;
 		    //Pointer to the map of distances.
 		    DistMap *_dist;
 		    //Indicates if _dist is locally allocated (true) or not.
 		    bool local_dist;
 		    //Pointer to the map of reached status of the nodes.
 		    ReachedMap *_reached;
 		    //Indicates if _reached is locally allocated (true) or not.
 		    bool local_reached;
 		    //Pointer to the map of processed status of the nodes.
 		    ProcessedMap *_processed;
 		    //Indicates if _processed is locally allocated (true) or not.
 		    bool local_processed;
 		    std::vector<typename Digraph::OutArcIt> _stack;
 		    int _stack_head;
 		    //Creates the maps if necessary.
 		    void create_maps()
+		    {
 		      if(!_pred) {
 		        local_pred = true;
 		        _pred = Traits::createPredMap(*G);
+		      }
 		      if(!_dist) {
 		        local_dist = true;
 		        _dist = Traits::createDistMap(*G);
+		      }
 		      if(!_reached) {
 		        local_reached = true;
 		        _reached = Traits::createReachedMap(*G);
+		      }
 		      if(!_processed) {
 		        local_processed = true;
 		        _processed = Traits::createProcessedMap(*G);
+		      }
+		    }
 		  protected:
 		    Dfs() {}
 		  public:
 		    typedef Dfs Create;
 		    ///\name Named Template Parameters
 		    ///@{
 		    template <class T>
 		    struct SetPredMapTraits : public Traits {
 		      typedef T PredMap;
 		      static PredMap *createPredMap(const Digraph &)
+		      {
 		        LEMON_ASSERT(false, "PredMap is not initialized");
 		        return 0; // ignore warnings
+		      }
 		    };
 		    ///\brief \ref named-templ-param "Named parameter" for setting
 		    ///\c PredMap type.
 		    ///
 		    ///\ref named-templ-param "Named parameter" for setting
 		    ///\c PredMap type.
 		    ///It must conform to the \ref concepts::WriteMap "WriteMap" concept.
 		    template <class T>
 		    struct SetPredMap : public Dfs<Digraph, SetPredMapTraits<T> > {
 		      typedef Dfs<Digraph, SetPredMapTraits<T> > Create;
 		    };
 		    template <class T>
 		    struct SetDistMapTraits : public Traits {
 		      typedef T DistMap;
 		      static DistMap *createDistMap(const Digraph &)
+		      {
 		        LEMON_ASSERT(false, "DistMap is not initialized");
 		        return 0; // ignore warnings
+		      }
 		    };
 		    ///\brief \ref named-templ-param "Named parameter" for setting
 		    ///\c DistMap type.
 		    ///
 		    ///\ref named-templ-param "Named parameter" for setting
 		    ///\c DistMap type.
 		    ///It must conform to the \ref concepts::WriteMap "WriteMap" concept.
 		    template <class T>
 		    struct SetDistMap : public Dfs< Digraph, SetDistMapTraits<T> > {
 		      typedef Dfs<Digraph, SetDistMapTraits<T> > Create;
 		    };
 		    template <class T>
 		    struct SetReachedMapTraits : public Traits {
 		      typedef T ReachedMap;
 		      static ReachedMap *createReachedMap(const Digraph &)
+		      {
 		        LEMON_ASSERT(false, "ReachedMap is not initialized");
 		        return 0; // ignore warnings
+		      }
 		    };
 		    ///\brief \ref named-templ-param "Named parameter" for setting
 		    ///\c ReachedMap type.
 		    ///
 		    ///\ref named-templ-param "Named parameter" for setting
 		    ///\c ReachedMap type.
 		    ///It must conform to the \ref concepts::ReadWriteMap "ReadWriteMap" concept.
 		    template <class T>
 		    struct SetReachedMap : public Dfs< Digraph, SetReachedMapTraits<T> > {
 		      typedef Dfs< Digraph, SetReachedMapTraits<T> > Create;
 		    };
 		    template <class T>
 		    struct SetProcessedMapTraits : public Traits {
 		      typedef T ProcessedMap;
 		      static ProcessedMap *createProcessedMap(const Digraph &)
+		      {
 		        LEMON_ASSERT(false, "ProcessedMap is not initialized");
 		        return 0; // ignore warnings
+		      }
 		    };
 		    ///\brief \ref named-templ-param "Named parameter" for setting
 		    ///\c ProcessedMap type.
 		    ///
 		    ///\ref named-templ-param "Named parameter" for setting
 		    ///\c ProcessedMap type.
 		    ///It must conform to the \ref concepts::WriteMap "WriteMap" concept.
 		    template <class T>
 		    struct SetProcessedMap : public Dfs< Digraph, SetProcessedMapTraits<T> > {
 		      typedef Dfs< Digraph, SetProcessedMapTraits<T> > Create;
 		    };
 		    struct SetStandardProcessedMapTraits : public Traits {
 		      typedef typename Digraph::template NodeMap<bool> ProcessedMap;
 		      static ProcessedMap *createProcessedMap(const Digraph &g)
+		      {
 		        return new ProcessedMap(g);
+		      }
 		    };
 		    ///\brief \ref named-templ-param "Named parameter" for setting
 		    ///\c ProcessedMap type to be <tt>Digraph::NodeMap<bool></tt>.
 		    ///
 		    ///\ref named-templ-param "Named parameter" for setting
 		    ///\c ProcessedMap type to be <tt>Digraph::NodeMap<bool></tt>.
 		    ///If you don't set it explicitly, it will be automatically allocated.
 		    struct SetStandardProcessedMap :
 		      public Dfs< Digraph, SetStandardProcessedMapTraits > {
 		      typedef Dfs< Digraph, SetStandardProcessedMapTraits > Create;
 		    };
 		    ///@}
 		  public:
 		    ///Constructor.
 		    ///Constructor.
 		    ///\param g The digraph the algorithm runs on.
 		    Dfs(const Digraph &g) :
 		      G(&g),
 		      _pred(NULL), local_pred(false),
 		      _dist(NULL), local_dist(false),
 		      _reached(NULL), local_reached(false),
 		      _processed(NULL), local_processed(false)
 		    { }
 		    ///Destructor.
 		    ~Dfs()
+		    {
 		      if(local_pred) delete _pred;
 		      if(local_dist) delete _dist;
 		      if(local_reached) delete _reached;
 		      if(local_processed) delete _processed;
+		    }
 		    ///Sets the map that stores the predecessor arcs.
 		    ///Sets the map that stores the predecessor arcs.
 		    ///If you don't use this function before calling \ref run(Node) "run()"
 		    ///or \ref init(), an instance will be allocated automatically.
 		    ///The destructor deallocates this automatically allocated map,
 		    ///of course.
 		    ///\return <tt> (*this) </tt>
 		    Dfs &predMap(PredMap &m)
+		    {
 		      if(local_pred) {
 		        delete _pred;
 		        local_pred=false;
+		      }
 		      _pred = &m;
 		      return *this;
+		    }
 		    ///Sets the map that indicates which nodes are reached.
 		    ///Sets the map that indicates which nodes are reached.
 		    ///If you don't use this function before calling \ref run(Node) "run()"
 		    ///or \ref init(), an instance will be allocated automatically.
 		    ///The destructor deallocates this automatically allocated map,
 		    ///of course.
 		    ///\return <tt> (*this) </tt>
 		    Dfs &reachedMap(ReachedMap &m)
+		    {
 		      if(local_reached) {
 		        delete _reached;
 		        local_reached=false;
+		      }
 		      _reached = &m;
 		      return *this;
+		    }
 		    ///Sets the map that indicates which nodes are processed.
 		    ///Sets the map that indicates which nodes are processed.
 		    ///If you don't use this function before calling \ref run(Node) "run()"
 		    ///or \ref init(), an instance will be allocated automatically.
 		    ///The destructor deallocates this automatically allocated map,
 		    ///of course.
 		    ///\return <tt> (*this) </tt>
 		    Dfs &processedMap(ProcessedMap &m)
+		    {
 		      if(local_processed) {
 		        delete _processed;
 		        local_processed=false;
+		      }
 		      _processed = &m;
 		      return *this;
+		    }
 		    ///Sets the map that stores the distances of the nodes.
 		    ///Sets the map that stores the distances of the nodes calculated by
 		    ///the algorithm.
 		    ///If you don't use this function before calling \ref run(Node) "run()"
 		    ///or \ref init(), an instance will be allocated automatically.
 		    ///The destructor deallocates this automatically allocated map,
 		    ///of course.
 		    ///\return <tt> (*this) </tt>
 		    Dfs &distMap(DistMap &m)
+		    {
 		      if(local_dist) {
 		        delete _dist;
 		        local_dist=false;
+		      }
 		      _dist = &m;
 		      return *this;
+		    }
 		  public:
 		    ///\name Execution Control
 		    ///The simplest way to execute the DFS algorithm is to use one of the
 		    ///member functions called \ref run(Node) "run()".\n
 		    ///If you need more control on the execution, first you have to call
 		    ///\ref init(), then you can add a source node with \ref addSource()
 		    ///If you need better control on the execution, you have to call
 		    ///\ref init() first, then you can add a source node with \ref addSource()
 		    ///and perform the actual computation with \ref start().
 		    ///This procedure can be repeated if there are nodes that have not
 		    ///been reached.
 		    ///@{
 		    ///\brief Initializes the internal data structures.
 		    ///
 		    ///Initializes the internal data structures.
 		    void init()
+		    {
 		      create_maps();
 		      _stack.resize(countNodes(*G));
 		      _stack_head=-1;
 		      for ( NodeIt u(*G) ; u!=INVALID ; ++u ) {
 		        _pred->set(u,INVALID);
 		        _reached->set(u,false);
 		        _processed->set(u,false);
+		      }
+		    }
 		    ///Adds a new source node.
 		    ///Adds a new source node to the set of nodes to be processed.
 		    ///
 		    ///\pre The stack must be empty. Otherwise the algorithm gives
 		    ///wrong results. (One of the outgoing arcs of all the source nodes
 		    ///except for the last one will not be visited and distances will
 		    ///also be wrong.)
 		    void addSource(Node s)
+		    {
 		      LEMON_DEBUG(emptyQueue(), "The stack is not empty.");
 		      if(!(*_reached)[s])
+		        {
 		          _reached->set(s,true);
 		          _pred->set(s,INVALID);
 		          OutArcIt e(*G,s);
 		          if(e!=INVALID) {
 		            _stack[++_stack_head]=e;
 		            _dist->set(s,_stack_head);
+		          }
 		          else {
 		            _processed->set(s,true);
 		            _dist->set(s,0);
+		          }
+		        }
+		    }
 		    ///Processes the next arc.
 		    ///Processes the next arc.
 		    ///
 		    ///\return The processed arc.
 		    ///
 		    ///\pre The stack must not be empty.
 		    Arc processNextArc()
+		    {
 		      Node m;
 		      Arc e=_stack[_stack_head];
 		      if(!(*_reached)[m=G->target(e)]) {
 		        _pred->set(m,e);
 		        _reached->set(m,true);
 		        ++_stack_head;
 		        _stack[_stack_head] = OutArcIt(*G, m);
 		        _dist->set(m,_stack_head);
+		      }
 		      else {
 		        m=G->source(e);
 		        ++_stack[_stack_head];
+		      }
 		      while(_stack_head>=0 && _stack[_stack_head]==INVALID) {
 		        _processed->set(m,true);
 		        --_stack_head;
 		        if(_stack_head>=0) {
 		          m=G->source(_stack[_stack_head]);
 		          ++_stack[_stack_head];
+		        }
+		      }
 		      return e;
+		    }
 		    ///Next arc to be processed.
 		    ///Next arc to be processed.
 		    ///
 		    ///\return The next arc to be processed or \c INVALID if the stack
 		    ///is empty.
 		    OutArcIt nextArc() const
+		    {
 		      return _stack_head>=0?_stack[_stack_head]:INVALID;
+		    }
 		    ///Returns \c false if there are nodes to be processed.
 		    ///Returns \c false if there are nodes to be processed
 		    ///in the queue (stack).
 		    bool emptyQueue() const { return _stack_head<0; }
 		    ///Returns the number of the nodes to be processed.
 		    ///Returns the number of the nodes to be processed
 		    ///in the queue (stack).
 		    int queueSize() const { return _stack_head+1; }
 		    ///Executes the algorithm.
 		    ///Executes the algorithm.
 		    ///
 		    ///This method runs the %DFS algorithm from the root node
 		    ///in order to compute the DFS path to each node.
 		    ///
 		    /// The algorithm computes
 		    ///- the %DFS tree,
 		    ///- the distance of each node from the root in the %DFS tree.
 		    ///
 		    ///\pre init() must be called and a root node should be
 		    ///added with addSource() before using this function.
 		    ///
 		    ///\note <tt>d.start()</tt> is just a shortcut of the following code.
 		    ///\code
 		    ///  while ( !d.emptyQueue() ) {
 		    ///    d.processNextArc();
 		    ///  }
 		    ///\endcode
 		    void start()
+		    {
 		      while ( !emptyQueue() ) processNextArc();
+		    }
 		    ///Executes the algorithm until the given target node is reached.
 		    ///Executes the algorithm until the given target node is reached.
 		    ///
 		    ///This method runs the %DFS algorithm from the root node
 		    ///in order to compute the DFS path to \c t.
 		    ///
 		    ///The algorithm computes
 		    ///- the %DFS path to \c t,
 		    ///- the distance of \c t from the root in the %DFS tree.
 		    ///
 		    ///\pre init() must be called and a root node should be
 		    ///added with addSource() before using this function.
 		    void start(Node t)
+		    {
 		      while ( !emptyQueue() && G->target(_stack[_stack_head])!=t )
 		        processNextArc();
+		    }
 		    ///Executes the algorithm until a condition is met.
 		    ///Executes the algorithm until a condition is met.
 		    ///
 		    ///This method runs the %DFS algorithm from the root node
 		    ///until an arc \c a with <tt>am[a]</tt> true is found.
 		    ///
 		    ///\param am A \c bool (or convertible) arc map. The algorithm
 		    ///will stop when it reaches an arc \c a with <tt>am[a]</tt> true.
 		    ///
 		    ///\return The reached arc \c a with <tt>am[a]</tt> true or
 		    ///\c INVALID if no such arc was found.
 		    ///
 		    ///\pre init() must be called and a root node should be
 		    ///added with addSource() before using this function.
 		    ///
 		    ///\warning Contrary to \ref Bfs and \ref Dijkstra, \c am is an arc map,
 		    ///not a node map.
 		    template<class ArcBoolMap>
 		    Arc start(const ArcBoolMap &am)
+		    {
 		      while ( !emptyQueue() && !am[_stack[_stack_head]] )
 		        processNextArc();
 		      return emptyQueue() ? INVALID : _stack[_stack_head];
+		    }
 		    ///Runs the algorithm from the given source node.
 		    ///This method runs the %DFS algorithm from node \c s
 		    ///in order to compute the DFS path to each node.
 		    ///
 		    ///The algorithm computes
 		    ///- the %DFS tree,
 		    ///- the distance of each node from the root in the %DFS tree.
 		    ///
 		    ///\note <tt>d.run(s)</tt> is just a shortcut of the following code.
 		    ///\code
 		    ///  d.init();
 		    ///  d.addSource(s);
 		    ///  d.start();
 		    ///\endcode
 		    void run(Node s) {
 		      init();
 		      addSource(s);
 		      start();
+		    }
 		    ///Finds the %DFS path between \c s and \c t.
 		    ///This method runs the %DFS algorithm from node \c s
 		    ///in order to compute the DFS path to node \c t
 		    ///(it stops searching when \c t is processed)
 		    ///
 		    ///\return \c true if \c t is reachable form \c s.
 		    ///
 		    ///\note Apart from the return value, <tt>d.run(s,t)</tt> is
 		    ///just a shortcut of the following code.
 		    ///\code
 		    ///  d.init();
 		    ///  d.addSource(s);
 		    ///  d.start(t);
 		    ///\endcode
 		    bool run(Node s,Node t) {
 		      init();
 		      addSource(s);
 		      start(t);
 		      return reached(t);
+		    }
 		    ///Runs the algorithm to visit all nodes in the digraph.
 		    ///This method runs the %DFS algorithm in order to compute the
 		    ///%DFS path to each node.
 		    ///
 		    ///The algorithm computes
 		    ///- the %DFS tree (forest),
 		    ///- the distance of each node from the root(s) in the %DFS tree.
 		    ///
 		    ///\note <tt>d.run()</tt> is just a shortcut of the following code.
 		    ///\code
 		    ///  d.init();
 		    ///  for (NodeIt n(digraph); n != INVALID; ++n) {
 		    ///    if (!d.reached(n)) {
 		    ///      d.addSource(n);
 		    ///      d.start();
 		    ///    }
 		    ///  }
 		    ///\endcode
 		    void run() {
 		      init();
 		      for (NodeIt it(*G); it != INVALID; ++it) {
 		        if (!reached(it)) {
 		          addSource(it);
 		          start();
+		        }
+		      }
+		    }
 		    ///@}
 		    ///\name Query Functions
 		    ///The results of the DFS algorithm can be obtained using these
 		    ///functions.\n
 		    ///Either \ref run(Node) "run()" or \ref start() should be called
 		    ///before using them.
 		    ///@{
@@ -1111,514 +1111,514 @@
 		  ///\sa Dfs
 		  template<class GR>
 		  DfsWizard<DfsWizardBase<GR> >
 		  dfs(const GR &digraph)
+		  {
 		    return DfsWizard<DfsWizardBase<GR> >(digraph);
+		  }
 		#ifdef DOXYGEN
 		  /// \brief Visitor class for DFS.
 		  ///
 		  /// This class defines the interface of the DfsVisit events, and
 		  /// it could be the base of a real visitor class.
 		  template <typename GR>
 		  struct DfsVisitor {
 		    typedef GR Digraph;
 		    typedef typename Digraph::Arc Arc;
 		    typedef typename Digraph::Node Node;
 		    /// \brief Called for the source node of the DFS.
 		    ///
 		    /// This function is called for the source node of the DFS.
 		    void start(const Node& node) {}
 		    /// \brief Called when the source node is leaved.
 		    ///
 		    /// This function is called when the source node is leaved.
 		    void stop(const Node& node) {}
 		    /// \brief Called when a node is reached first time.
 		    ///
 		    /// This function is called when a node is reached first time.
 		    void reach(const Node& node) {}
 		    /// \brief Called when an arc reaches a new node.
 		    ///
 		    /// This function is called when the DFS finds an arc whose target node
 		    /// is not reached yet.
 		    void discover(const Arc& arc) {}
 		    /// \brief Called when an arc is examined but its target node is
 		    /// already discovered.
 		    ///
 		    /// This function is called when an arc is examined but its target node is
 		    /// already discovered.
 		    void examine(const Arc& arc) {}
 		    /// \brief Called when the DFS steps back from a node.
 		    ///
 		    /// This function is called when the DFS steps back from a node.
 		    void leave(const Node& node) {}
 		    /// \brief Called when the DFS steps back on an arc.
 		    ///
 		    /// This function is called when the DFS steps back on an arc.
 		    void backtrack(const Arc& arc) {}
 		  };
 		#else
 		  template <typename GR>
 		  struct DfsVisitor {
 		    typedef GR Digraph;
 		    typedef typename Digraph::Arc Arc;
 		    typedef typename Digraph::Node Node;
 		    void start(const Node&) {}
 		    void stop(const Node&) {}
 		    void reach(const Node&) {}
 		    void discover(const Arc&) {}
 		    void examine(const Arc&) {}
 		    void leave(const Node&) {}
 		    void backtrack(const Arc&) {}
 		    template <typename _Visitor>
 		    struct Constraints {
 		      void constraints() {
 		        Arc arc;
 		        Node node;
 		        visitor.start(node);
 		        visitor.stop(arc);
 		        visitor.reach(node);
 		        visitor.discover(arc);
 		        visitor.examine(arc);
 		        visitor.leave(node);
 		        visitor.backtrack(arc);
+		      }
 		      _Visitor& visitor;
 		    };
 		  };
 		#endif
 		  /// \brief Default traits class of DfsVisit class.
 		  ///
 		  /// Default traits class of DfsVisit class.
 		  /// \tparam _Digraph The type of the digraph the algorithm runs on.
 		  template<class GR>
 		  struct DfsVisitDefaultTraits {
 		    /// \brief The type of the digraph the algorithm runs on.
 		    typedef GR Digraph;
 		    /// \brief The type of the map that indicates which nodes are reached.
 		    ///
 		    /// The type of the map that indicates which nodes are reached.
 		    /// It must conform to the \ref concepts::ReadWriteMap "ReadWriteMap" concept.
 		    typedef typename Digraph::template NodeMap<bool> ReachedMap;
 		    /// \brief Instantiates a ReachedMap.
 		    ///
 		    /// This function instantiates a ReachedMap.
 		    /// \param digraph is the digraph, to which
 		    /// we would like to define the ReachedMap.
 		    static ReachedMap *createReachedMap(const Digraph &digraph) {
 		      return new ReachedMap(digraph);
+		    }
 		  };
 		  /// \ingroup search
 		  ///
 		  /// \brief DFS algorithm class with visitor interface.
 		  ///
 		  /// This class provides an efficient implementation of the DFS algorithm
 		  /// with visitor interface.
 		  ///
 		  /// The DfsVisit class provides an alternative interface to the Dfs
 		  /// class. It works with callback mechanism, the DfsVisit object calls
 		  /// the member functions of the \c Visitor class on every DFS event.
 		  ///
 		  /// This interface of the DFS algorithm should be used in special cases
 		  /// when extra actions have to be performed in connection with certain
 		  /// events of the DFS algorithm. Otherwise consider to use Dfs or dfs()
 		  /// instead.
 		  ///
 		  /// \tparam GR The type of the digraph the algorithm runs on.
 		  /// The default type is \ref ListDigraph.
 		  /// The value of GR is not used directly by \ref DfsVisit,
 		  /// it is only passed to \ref DfsVisitDefaultTraits.
 		  /// \tparam VS The Visitor type that is used by the algorithm.
 		  /// \ref DfsVisitor "DfsVisitor<GR>" is an empty visitor, which
 		  /// does not observe the DFS events. If you want to observe the DFS
 		  /// events, you should implement your own visitor class.
 		  /// \tparam TR Traits class to set various data types used by the
 		  /// algorithm. The default traits class is
 		  /// \ref DfsVisitDefaultTraits "DfsVisitDefaultTraits<GR>".
 		  /// See \ref DfsVisitDefaultTraits for the documentation of
 		  /// a DFS visit traits class.
 		#ifdef DOXYGEN
 		  template <typename GR, typename VS, typename TR>
 		#else
 		  template <typename GR = ListDigraph,
 		            typename VS = DfsVisitor<GR>,
 		            typename TR = DfsVisitDefaultTraits<GR> >
 		#endif
 		  class DfsVisit {
 		  public:
 		    ///The traits class.
 		    typedef TR Traits;
 		    ///The type of the digraph the algorithm runs on.
 		    typedef typename Traits::Digraph Digraph;
 		    ///The visitor type used by the algorithm.
 		    typedef VS Visitor;
 		    ///The type of the map that indicates which nodes are reached.
 		    typedef typename Traits::ReachedMap ReachedMap;
 		  private:
 		    typedef typename Digraph::Node Node;
 		    typedef typename Digraph::NodeIt NodeIt;
 		    typedef typename Digraph::Arc Arc;
 		    typedef typename Digraph::OutArcIt OutArcIt;
 		    //Pointer to the underlying digraph.
 		    const Digraph *_digraph;
 		    //Pointer to the visitor object.
 		    Visitor *_visitor;
 		    //Pointer to the map of reached status of the nodes.
 		    ReachedMap *_reached;
 		    //Indicates if _reached is locally allocated (true) or not.
 		    bool local_reached;
 		    std::vector<typename Digraph::Arc> _stack;
 		    int _stack_head;
 		    //Creates the maps if necessary.
 		    void create_maps() {
 		      if(!_reached) {
 		        local_reached = true;
 		        _reached = Traits::createReachedMap(*_digraph);
+		      }
+		    }
 		  protected:
 		    DfsVisit() {}
 		  public:
 		    typedef DfsVisit Create;
 		    /// \name Named Template Parameters
 		    ///@{
 		    template <class T>
 		    struct SetReachedMapTraits : public Traits {
 		      typedef T ReachedMap;
 		      static ReachedMap *createReachedMap(const Digraph &digraph) {
 		        LEMON_ASSERT(false, "ReachedMap is not initialized");
 		        return 0; // ignore warnings
+		      }
 		    };
 		    /// \brief \ref named-templ-param "Named parameter" for setting
 		    /// ReachedMap type.
 		    ///
 		    /// \ref named-templ-param "Named parameter" for setting ReachedMap type.
 		    template <class T>
 		    struct SetReachedMap : public DfsVisit< Digraph, Visitor,
 		                                            SetReachedMapTraits<T> > {
 		      typedef DfsVisit< Digraph, Visitor, SetReachedMapTraits<T> > Create;
 		    };
 		    ///@}
 		  public:
 		    /// \brief Constructor.
 		    ///
 		    /// Constructor.
 		    ///
 		    /// \param digraph The digraph the algorithm runs on.
 		    /// \param visitor The visitor object of the algorithm.
 		    DfsVisit(const Digraph& digraph, Visitor& visitor)
 		      : _digraph(&digraph), _visitor(&visitor),
 		        _reached(0), local_reached(false) {}
 		    /// \brief Destructor.
 		    ~DfsVisit() {
 		      if(local_reached) delete _reached;
+		    }
 		    /// \brief Sets the map that indicates which nodes are reached.
 		    ///
 		    /// Sets the map that indicates which nodes are reached.
 		    /// If you don't use this function before calling \ref run(Node) "run()"
 		    /// or \ref init(), an instance will be allocated automatically.
 		    /// The destructor deallocates this automatically allocated map,
 		    /// of course.
 		    /// \return <tt> (*this) </tt>
 		    DfsVisit &reachedMap(ReachedMap &m) {
 		      if(local_reached) {
 		        delete _reached;
 		        local_reached=false;
+		      }
 		      _reached = &m;
 		      return *this;
+		    }
 		  public:
 		    /// \name Execution Control
 		    /// The simplest way to execute the DFS algorithm is to use one of the
 		    /// member functions called \ref run(Node) "run()".\n
 		    /// If you need more control on the execution, first you have to call
 		    /// \ref init(), then you can add a source node with \ref addSource()
 		    /// If you need better control on the execution, you have to call
 		    /// \ref init() first, then you can add a source node with \ref addSource()
 		    /// and perform the actual computation with \ref start().
 		    /// This procedure can be repeated if there are nodes that have not
 		    /// been reached.
 		    /// @{
 		    /// \brief Initializes the internal data structures.
 		    ///
 		    /// Initializes the internal data structures.
 		    void init() {
 		      create_maps();
 		      _stack.resize(countNodes(*_digraph));
 		      _stack_head = -1;
 		      for (NodeIt u(*_digraph) ; u != INVALID ; ++u) {
 		        _reached->set(u, false);
+		      }
+		    }
 		    /// \brief Adds a new source node.
 		    ///
 		    /// Adds a new source node to the set of nodes to be processed.
 		    ///
 		    /// \pre The stack must be empty. Otherwise the algorithm gives
 		    /// wrong results. (One of the outgoing arcs of all the source nodes
 		    /// except for the last one will not be visited and distances will
 		    /// also be wrong.)
 		    void addSource(Node s)
+		    {
 		      LEMON_DEBUG(emptyQueue(), "The stack is not empty.");
 		      if(!(*_reached)[s]) {
 		          _reached->set(s,true);
 		          _visitor->start(s);
 		          _visitor->reach(s);
 		          Arc e;
 		          _digraph->firstOut(e, s);
 		          if (e != INVALID) {
 		            _stack[++_stack_head] = e;
 		          } else {
 		            _visitor->leave(s);
 		            _visitor->stop(s);
+		          }
+		        }
+		    }
 		    /// \brief Processes the next arc.
 		    ///
 		    /// Processes the next arc.
 		    ///
 		    /// \return The processed arc.
 		    ///
 		    /// \pre The stack must not be empty.
 		    Arc processNextArc() {
 		      Arc e = _stack[_stack_head];
 		      Node m = _digraph->target(e);
 		      if(!(*_reached)[m]) {
 		        _visitor->discover(e);
 		        _visitor->reach(m);
 		        _reached->set(m, true);
 		        _digraph->firstOut(_stack[++_stack_head], m);
 		      } else {
 		        _visitor->examine(e);
 		        m = _digraph->source(e);
 		        _digraph->nextOut(_stack[_stack_head]);
+		      }
 		      while (_stack_head>=0 && _stack[_stack_head] == INVALID) {
 		        _visitor->leave(m);
 		        --_stack_head;
 		        if (_stack_head >= 0) {
 		          _visitor->backtrack(_stack[_stack_head]);
 		          m = _digraph->source(_stack[_stack_head]);
 		          _digraph->nextOut(_stack[_stack_head]);
 		        } else {
 		          _visitor->stop(m);
+		        }
+		      }
 		      return e;
+		    }
 		    /// \brief Next arc to be processed.
 		    ///
 		    /// Next arc to be processed.
 		    ///
 		    /// \return The next arc to be processed or INVALID if the stack is
 		    /// empty.
 		    Arc nextArc() const {
 		      return _stack_head >= 0 ? _stack[_stack_head] : INVALID;
+		    }
 		    /// \brief Returns \c false if there are nodes
 		    /// to be processed.
 		    ///
 		    /// Returns \c false if there are nodes
 		    /// to be processed in the queue (stack).
 		    bool emptyQueue() const { return _stack_head < 0; }
 		    /// \brief Returns the number of the nodes to be processed.
 		    ///
 		    /// Returns the number of the nodes to be processed in the queue (stack).
 		    int queueSize() const { return _stack_head + 1; }
 		    /// \brief Executes the algorithm.
 		    ///
 		    /// Executes the algorithm.
 		    ///
 		    /// This method runs the %DFS algorithm from the root node
 		    /// in order to compute the %DFS path to each node.
 		    ///
 		    /// The algorithm computes
 		    /// - the %DFS tree,
 		    /// - the distance of each node from the root in the %DFS tree.
 		    ///
 		    /// \pre init() must be called and a root node should be
 		    /// added with addSource() before using this function.
 		    ///
 		    /// \note <tt>d.start()</tt> is just a shortcut of the following code.
 		    /// \code
 		    ///   while ( !d.emptyQueue() ) {
 		    ///     d.processNextArc();
 		    ///   }
 		    /// \endcode
 		    void start() {
 		      while ( !emptyQueue() ) processNextArc();
+		    }
 		    /// \brief Executes the algorithm until the given target node is reached.
 		    ///
 		    /// Executes the algorithm until the given target node is reached.
 		    ///
 		    /// This method runs the %DFS algorithm from the root node
 		    /// in order to compute the DFS path to \c t.
 		    ///
 		    /// The algorithm computes
 		    /// - the %DFS path to \c t,
 		    /// - the distance of \c t from the root in the %DFS tree.
 		    ///
 		    /// \pre init() must be called and a root node should be added
 		    /// with addSource() before using this function.
 		    void start(Node t) {
 		      while ( !emptyQueue() && _digraph->target(_stack[_stack_head]) != t )
 		        processNextArc();
+		    }
 		    /// \brief Executes the algorithm until a condition is met.
 		    ///
 		    /// Executes the algorithm until a condition is met.
 		    ///
 		    /// This method runs the %DFS algorithm from the root node
 		    /// until an arc \c a with <tt>am[a]</tt> true is found.
 		    ///
 		    /// \param am A \c bool (or convertible) arc map. The algorithm
 		    /// will stop when it reaches an arc \c a with <tt>am[a]</tt> true.
 		    ///
 		    /// \return The reached arc \c a with <tt>am[a]</tt> true or
 		    /// \c INVALID if no such arc was found.
 		    ///
 		    /// \pre init() must be called and a root node should be added
 		    /// with addSource() before using this function.
 		    ///
 		    /// \warning Contrary to \ref Bfs and \ref Dijkstra, \c am is an arc map,
 		    /// not a node map.
 		    template <typename AM>
 		    Arc start(const AM &am) {
 		      while ( !emptyQueue() && !am[_stack[_stack_head]] )
 		        processNextArc();
 		      return emptyQueue() ? INVALID : _stack[_stack_head];
+		    }
 		    /// \brief Runs the algorithm from the given source node.
 		    ///
 		    /// This method runs the %DFS algorithm from node \c s.
 		    /// in order to compute the DFS path to each node.
 		    ///
 		    /// The algorithm computes
 		    /// - the %DFS tree,
 		    /// - the distance of each node from the root in the %DFS tree.
 		    ///
 		    /// \note <tt>d.run(s)</tt> is just a shortcut of the following code.
 		    ///\code
 		    ///   d.init();
 		    ///   d.addSource(s);
 		    ///   d.start();
 		    ///\endcode
 		    void run(Node s) {
 		      init();
 		      addSource(s);
 		      start();
+		    }
 		    /// \brief Finds the %DFS path between \c s and \c t.
 		    /// This method runs the %DFS algorithm from node \c s
 		    /// in order to compute the DFS path to node \c t
 		    /// (it stops searching when \c t is processed).
 		    ///
 		    /// \return \c true if \c t is reachable form \c s.
 		    ///
 		    /// \note Apart from the return value, <tt>d.run(s,t)</tt> is
 		    /// just a shortcut of the following code.
 		    ///\code
 		    ///   d.init();
 		    ///   d.addSource(s);
 		    ///   d.start(t);
 		    ///\endcode
 		    bool run(Node s,Node t) {
 		      init();
 		      addSource(s);
 		      start(t);
 		      return reached(t);
+		    }
 		    /// \brief Runs the algorithm to visit all nodes in the digraph.
 		    /// This method runs the %DFS algorithm in order to
 		    /// compute the %DFS path to each node.
 		    ///
 		    /// The algorithm computes
 		    /// - the %DFS tree (forest),
 		    /// - the distance of each node from the root(s) in the %DFS tree.
 		    ///
 		    /// \note <tt>d.run()</tt> is just a shortcut of the following code.
 		    ///\code
 		    ///   d.init();
 		    ///   for (NodeIt n(digraph); n != INVALID; ++n) {
 		    ///     if (!d.reached(n)) {
 		    ///       d.addSource(n);
 		    ///       d.start();
 		    ///     }
 		    ///   }
 		    ///\endcode
 		    void run() {
 		      init();
 		      for (NodeIt it(*_digraph); it != INVALID; ++it) {
 		        if (!reached(it)) {
 		          addSource(it);
 		          start();
+		        }
+		      }
+		    }
 		    ///@}
 		    /// \name Query Functions
 		    /// The results of the DFS algorithm can be obtained using these
 		    /// functions.\n
 		    /// Either \ref run(Node) "run()" or \ref start() should be called
 		    /// before using them.
 		    ///@{
 		    /// \brief Checks if the given node is reached from the root(s).
 		    ///
 		    /// Returns \c true if \c v is reached from the root(s).
 		    ///
 		    /// \pre Either \ref run(Node) "run()" or \ref init()
 		    /// must be called before using this function.
 		    bool reached(Node v) const { return (*_reached)[v]; }

lemon/dijkstra.h

Show inline comments

@@ -336,514 +336,514 @@
 		      typedef Dijkstra< Digraph, LengthMap, SetDistMapTraits<T> > Create;
 		    };
 		    template <class T>
 		    struct SetProcessedMapTraits : public Traits {
 		      typedef T ProcessedMap;
 		      static ProcessedMap *createProcessedMap(const Digraph &)
+		      {
 		        LEMON_ASSERT(false, "ProcessedMap is not initialized");
 		        return 0; // ignore warnings
+		      }
 		    };
 		    ///\brief \ref named-templ-param "Named parameter" for setting
 		    ///\c ProcessedMap type.
 		    ///
 		    ///\ref named-templ-param "Named parameter" for setting
 		    ///\c ProcessedMap type.
 		    ///It must conform to the \ref concepts::WriteMap "WriteMap" concept.
 		    template <class T>
 		    struct SetProcessedMap
 		      : public Dijkstra< Digraph, LengthMap, SetProcessedMapTraits<T> > {
 		      typedef Dijkstra< Digraph, LengthMap, SetProcessedMapTraits<T> > Create;
 		    };
 		    struct SetStandardProcessedMapTraits : public Traits {
 		      typedef typename Digraph::template NodeMap<bool> ProcessedMap;
 		      static ProcessedMap *createProcessedMap(const Digraph &g)
+		      {
 		        return new ProcessedMap(g);
+		      }
 		    };
 		    ///\brief \ref named-templ-param "Named parameter" for setting
 		    ///\c ProcessedMap type to be <tt>Digraph::NodeMap<bool></tt>.
 		    ///
 		    ///\ref named-templ-param "Named parameter" for setting
 		    ///\c ProcessedMap type to be <tt>Digraph::NodeMap<bool></tt>.
 		    ///If you don't set it explicitly, it will be automatically allocated.
 		    struct SetStandardProcessedMap
 		      : public Dijkstra< Digraph, LengthMap, SetStandardProcessedMapTraits > {
 		      typedef Dijkstra< Digraph, LengthMap, SetStandardProcessedMapTraits >
 		      Create;
 		    };
 		    template <class H, class CR>
 		    struct SetHeapTraits : public Traits {
 		      typedef CR HeapCrossRef;
 		      typedef H Heap;
 		      static HeapCrossRef *createHeapCrossRef(const Digraph &) {
 		        LEMON_ASSERT(false, "HeapCrossRef is not initialized");
 		        return 0; // ignore warnings
+		      }
 		      static Heap *createHeap(HeapCrossRef &)
+		      {
 		        LEMON_ASSERT(false, "Heap is not initialized");
 		        return 0; // ignore warnings
+		      }
 		    };
 		    ///\brief \ref named-templ-param "Named parameter" for setting
 		    ///heap and cross reference types
 		    ///
 		    ///\ref named-templ-param "Named parameter" for setting heap and cross
 		    ///reference types. If this named parameter is used, then external
 		    ///heap and cross reference objects must be passed to the algorithm
 		    ///using the \ref heap() function before calling \ref run(Node) "run()"
 		    ///or \ref init().
 		    ///\sa SetStandardHeap
 		    template <class H, class CR = typename Digraph::template NodeMap<int> >
 		    struct SetHeap
 		      : public Dijkstra< Digraph, LengthMap, SetHeapTraits<H, CR> > {
 		      typedef Dijkstra< Digraph, LengthMap, SetHeapTraits<H, CR> > Create;
 		    };
 		    template <class H, class CR>
 		    struct SetStandardHeapTraits : public Traits {
 		      typedef CR HeapCrossRef;
 		      typedef H Heap;
 		      static HeapCrossRef *createHeapCrossRef(const Digraph &G) {
 		        return new HeapCrossRef(G);
+		      }
 		      static Heap *createHeap(HeapCrossRef &R)
+		      {
 		        return new Heap(R);
+		      }
 		    };
 		    ///\brief \ref named-templ-param "Named parameter" for setting
 		    ///heap and cross reference types with automatic allocation
 		    ///
 		    ///\ref named-templ-param "Named parameter" for setting heap and cross
 		    ///reference types with automatic allocation.
 		    ///They should have standard constructor interfaces to be able to
 		    ///automatically created by the algorithm (i.e. the digraph should be
 		    ///passed to the constructor of the cross reference and the cross
 		    ///reference should be passed to the constructor of the heap).
 		    ///However external heap and cross reference objects could also be
 		    ///passed to the algorithm using the \ref heap() function before
 		    ///calling \ref run(Node) "run()" or \ref init().
 		    ///\sa SetHeap
 		    template <class H, class CR = typename Digraph::template NodeMap<int> >
 		    struct SetStandardHeap
 		      : public Dijkstra< Digraph, LengthMap, SetStandardHeapTraits<H, CR> > {
 		      typedef Dijkstra< Digraph, LengthMap, SetStandardHeapTraits<H, CR> >
 		      Create;
 		    };
 		    template <class T>
 		    struct SetOperationTraitsTraits : public Traits {
 		      typedef T OperationTraits;
 		    };
 		    /// \brief \ref named-templ-param "Named parameter" for setting
 		    ///\c OperationTraits type
 		    ///
 		    ///\ref named-templ-param "Named parameter" for setting
 		    ///\c OperationTraits type.
 		    /// For more information see \ref DijkstraDefaultOperationTraits.
 		    template <class T>
 		    struct SetOperationTraits
 		      : public Dijkstra<Digraph, LengthMap, SetOperationTraitsTraits<T> > {
 		      typedef Dijkstra<Digraph, LengthMap, SetOperationTraitsTraits<T> >
 		      Create;
 		    };
 		    ///@}
 		  protected:
 		    Dijkstra() {}
 		  public:
 		    ///Constructor.
 		    ///Constructor.
 		    ///\param g The digraph the algorithm runs on.
 		    ///\param length The length map used by the algorithm.
 		    Dijkstra(const Digraph& g, const LengthMap& length) :
 		      G(&g), _length(&length),
 		      _pred(NULL), local_pred(false),
 		      _dist(NULL), local_dist(false),
 		      _processed(NULL), local_processed(false),
 		      _heap_cross_ref(NULL), local_heap_cross_ref(false),
 		      _heap(NULL), local_heap(false)
 		    { }
 		    ///Destructor.
 		    ~Dijkstra()
+		    {
 		      if(local_pred) delete _pred;
 		      if(local_dist) delete _dist;
 		      if(local_processed) delete _processed;
 		      if(local_heap_cross_ref) delete _heap_cross_ref;
 		      if(local_heap) delete _heap;
+		    }
 		    ///Sets the length map.
 		    ///Sets the length map.
 		    ///\return <tt> (*this) </tt>
 		    Dijkstra &lengthMap(const LengthMap &m)
+		    {
 		      _length = &m;
 		      return *this;
+		    }
 		    ///Sets the map that stores the predecessor arcs.
 		    ///Sets the map that stores the predecessor arcs.
 		    ///If you don't use this function before calling \ref run(Node) "run()"
 		    ///or \ref init(), an instance will be allocated automatically.
 		    ///The destructor deallocates this automatically allocated map,
 		    ///of course.
 		    ///\return <tt> (*this) </tt>
 		    Dijkstra &predMap(PredMap &m)
+		    {
 		      if(local_pred) {
 		        delete _pred;
 		        local_pred=false;
+		      }
 		      _pred = &m;
 		      return *this;
+		    }
 		    ///Sets the map that indicates which nodes are processed.
 		    ///Sets the map that indicates which nodes are processed.
 		    ///If you don't use this function before calling \ref run(Node) "run()"
 		    ///or \ref init(), an instance will be allocated automatically.
 		    ///The destructor deallocates this automatically allocated map,
 		    ///of course.
 		    ///\return <tt> (*this) </tt>
 		    Dijkstra &processedMap(ProcessedMap &m)
+		    {
 		      if(local_processed) {
 		        delete _processed;
 		        local_processed=false;
+		      }
 		      _processed = &m;
 		      return *this;
+		    }
 		    ///Sets the map that stores the distances of the nodes.
 		    ///Sets the map that stores the distances of the nodes calculated by the
 		    ///algorithm.
 		    ///If you don't use this function before calling \ref run(Node) "run()"
 		    ///or \ref init(), an instance will be allocated automatically.
 		    ///The destructor deallocates this automatically allocated map,
 		    ///of course.
 		    ///\return <tt> (*this) </tt>
 		    Dijkstra &distMap(DistMap &m)
+		    {
 		      if(local_dist) {
 		        delete _dist;
 		        local_dist=false;
+		      }
 		      _dist = &m;
 		      return *this;
+		    }
 		    ///Sets the heap and the cross reference used by algorithm.
 		    ///Sets the heap and the cross reference used by algorithm.
 		    ///If you don't use this function before calling \ref run(Node) "run()"
 		    ///or \ref init(), heap and cross reference instances will be
 		    ///allocated automatically.
 		    ///The destructor deallocates these automatically allocated objects,
 		    ///of course.
 		    ///\return <tt> (*this) </tt>
 		    Dijkstra &heap(Heap& hp, HeapCrossRef &cr)
+		    {
 		      if(local_heap_cross_ref) {
 		        delete _heap_cross_ref;
 		        local_heap_cross_ref=false;
+		      }
 		      _heap_cross_ref = &cr;
 		      if(local_heap) {
 		        delete _heap;
 		        local_heap=false;
+		      }
 		      _heap = &hp;
 		      return *this;
+		    }
 		  private:
 		    void finalizeNodeData(Node v,Value dst)
+		    {
 		      _processed->set(v,true);
 		      _dist->set(v, dst);
+		    }
 		  public:
 		    ///\name Execution Control
 		    ///The simplest way to execute the %Dijkstra algorithm is to use
 		    ///one of the member functions called \ref run(Node) "run()".\n
 		    ///If you need more control on the execution, first you have to call
 		    ///\ref init(), then you can add several source nodes with
 		    ///If you need better control on the execution, you have to call
 		    ///\ref init() first, then you can add several source nodes with
 		    ///\ref addSource(). Finally the actual path computation can be
 		    ///performed with one of the \ref start() functions.
 		    ///@{
 		    ///\brief Initializes the internal data structures.
 		    ///
 		    ///Initializes the internal data structures.
 		    void init()
+		    {
 		      create_maps();
 		      _heap->clear();
 		      for ( NodeIt u(*G) ; u!=INVALID ; ++u ) {
 		        _pred->set(u,INVALID);
 		        _processed->set(u,false);
 		        _heap_cross_ref->set(u,Heap::PRE_HEAP);
+		      }
+		    }
 		    ///Adds a new source node.
 		    ///Adds a new source node to the priority heap.
 		    ///The optional second parameter is the initial distance of the node.
 		    ///
 		    ///The function checks if the node has already been added to the heap and
 		    ///it is pushed to the heap only if either it was not in the heap
 		    ///or the shortest path found till then is shorter than \c dst.
 		    void addSource(Node s,Value dst=OperationTraits::zero())
+		    {
 		      if(_heap->state(s) != Heap::IN_HEAP) {
 		        _heap->push(s,dst);
 		      } else if(OperationTraits::less((*_heap)[s], dst)) {
 		        _heap->set(s,dst);
 		        _pred->set(s,INVALID);
+		      }
+		    }
 		    ///Processes the next node in the priority heap
 		    ///Processes the next node in the priority heap.
 		    ///
 		    ///\return The processed node.
 		    ///
 		    ///\warning The priority heap must not be empty.
 		    Node processNextNode()
+		    {
 		      Node v=_heap->top();
 		      Value oldvalue=_heap->prio();
 		      _heap->pop();
 		      finalizeNodeData(v,oldvalue);
 		      for(OutArcIt e(*G,v); e!=INVALID; ++e) {
 		        Node w=G->target(e);
 		        switch(_heap->state(w)) {
 		        case Heap::PRE_HEAP:
 		          _heap->push(w,OperationTraits::plus(oldvalue, (*_length)[e]));
 		          _pred->set(w,e);
 		          break;
 		        case Heap::IN_HEAP:
+		          {
 		            Value newvalue = OperationTraits::plus(oldvalue, (*_length)[e]);
 		            if ( OperationTraits::less(newvalue, (*_heap)[w]) ) {
 		              _heap->decrease(w, newvalue);
 		              _pred->set(w,e);
+		            }
+		          }
 		          break;
 		        case Heap::POST_HEAP:
 		          break;
+		        }
+		      }
 		      return v;
+		    }
 		    ///The next node to be processed.
 		    ///Returns the next node to be processed or \c INVALID if the
 		    ///priority heap is empty.
 		    Node nextNode() const
+		    {
 		      return !_heap->empty()?_heap->top():INVALID;
+		    }
 		    ///Returns \c false if there are nodes to be processed.
 		    ///Returns \c false if there are nodes to be processed
 		    ///in the priority heap.
 		    bool emptyQueue() const { return _heap->empty(); }
 		    ///Returns the number of the nodes to be processed.
 		    ///Returns the number of the nodes to be processed
 		    ///in the priority heap.
 		    int queueSize() const { return _heap->size(); }
 		    ///Executes the algorithm.
 		    ///Executes the algorithm.
 		    ///
 		    ///This method runs the %Dijkstra algorithm from the root node(s)
 		    ///in order to compute the shortest path to each node.
 		    ///
 		    ///The algorithm computes
 		    ///- the shortest path tree (forest),
 		    ///- the distance of each node from the root(s).
 		    ///
 		    ///\pre init() must be called and at least one root node should be
 		    ///added with addSource() before using this function.
 		    ///
 		    ///\note <tt>d.start()</tt> is just a shortcut of the following code.
 		    ///\code
 		    ///  while ( !d.emptyQueue() ) {
 		    ///    d.processNextNode();
 		    ///  }
 		    ///\endcode
 		    void start()
+		    {
 		      while ( !emptyQueue() ) processNextNode();
+		    }
 		    ///Executes the algorithm until the given target node is processed.
 		    ///Executes the algorithm until the given target node is processed.
 		    ///
 		    ///This method runs the %Dijkstra algorithm from the root node(s)
 		    ///in order to compute the shortest path to \c t.
 		    ///
 		    ///The algorithm computes
 		    ///- the shortest path to \c t,
 		    ///- the distance of \c t from the root(s).
 		    ///
 		    ///\pre init() must be called and at least one root node should be
 		    ///added with addSource() before using this function.
 		    void start(Node t)
+		    {
 		      while ( !_heap->empty() && _heap->top()!=t ) processNextNode();
 		      if ( !_heap->empty() ) {
 		        finalizeNodeData(_heap->top(),_heap->prio());
 		        _heap->pop();
+		      }
+		    }
 		    ///Executes the algorithm until a condition is met.
 		    ///Executes the algorithm until a condition is met.
 		    ///
 		    ///This method runs the %Dijkstra algorithm from the root node(s) in
 		    ///order to compute the shortest path to a node \c v with
 		    /// <tt>nm[v]</tt> true, if such a node can be found.
 		    ///
 		    ///\param nm A \c bool (or convertible) node map. The algorithm
 		    ///will stop when it reaches a node \c v with <tt>nm[v]</tt> true.
 		    ///
 		    ///\return The reached node \c v with <tt>nm[v]</tt> true or
 		    ///\c INVALID if no such node was found.
 		    ///
 		    ///\pre init() must be called and at least one root node should be
 		    ///added with addSource() before using this function.
 		    template<class NodeBoolMap>
 		    Node start(const NodeBoolMap &nm)
+		    {
 		      while ( !_heap->empty() && !nm[_heap->top()] ) processNextNode();
 		      if ( _heap->empty() ) return INVALID;
 		      finalizeNodeData(_heap->top(),_heap->prio());
 		      return _heap->top();
+		    }
 		    ///Runs the algorithm from the given source node.
 		    ///This method runs the %Dijkstra algorithm from node \c s
 		    ///in order to compute the shortest path to each node.
 		    ///
 		    ///The algorithm computes
 		    ///- the shortest path tree,
 		    ///- the distance of each node from the root.
 		    ///
 		    ///\note <tt>d.run(s)</tt> is just a shortcut of the following code.
 		    ///\code
 		    ///  d.init();
 		    ///  d.addSource(s);
 		    ///  d.start();
 		    ///\endcode
 		    void run(Node s) {
 		      init();
 		      addSource(s);
 		      start();
+		    }
 		    ///Finds the shortest path between \c s and \c t.
 		    ///This method runs the %Dijkstra algorithm from node \c s
 		    ///in order to compute the shortest path to node \c t
 		    ///(it stops searching when \c t is processed).
 		    ///
 		    ///\return \c true if \c t is reachable form \c s.
 		    ///
 		    ///\note Apart from the return value, <tt>d.run(s,t)</tt> is just a
 		    ///shortcut of the following code.
 		    ///\code
 		    ///  d.init();
 		    ///  d.addSource(s);
 		    ///  d.start(t);
 		    ///\endcode
 		    bool run(Node s,Node t) {
 		      init();
 		      addSource(s);
 		      start(t);
 		      return (*_heap_cross_ref)[t] == Heap::POST_HEAP;
+		    }
 		    ///@}
 		    ///\name Query Functions
 		    ///The results of the %Dijkstra algorithm can be obtained using these
 		    ///functions.\n
 		    ///Either \ref run(Node) "run()" or \ref init() should be called
 		    ///before using them.
 		    ///@{
 		    ///The shortest path to the given node.
 		    ///Returns the shortest path to the given node from the root(s).
 		    ///
 		    ///\warning \c t should be reached from the root(s).
 		    ///
 		    ///\pre Either \ref run(Node) "run()" or \ref init()
 		    ///must be called before using this function.
 		    Path path(Node t) const { return Path(*G, *_pred, t); }
 		    ///The distance of the given node from the root(s).
 		    ///Returns the distance of the given node from the root(s).
 		    ///
 		    ///\warning If node \c v is not reached from the root(s), then
 		    ///the return value of this function is undefined.
 		    ///
 		    ///\pre Either \ref run(Node) "run()" or \ref init()
 		    ///must be called before using this function.
 		    Value dist(Node v) const { return (*_dist)[v]; }
 		    ///\brief Returns the 'previous arc' of the shortest path tree for
 		    ///the given node.
 		    ///
 		    ///This function returns the 'previous arc' of the shortest path
 		    ///tree for the node \c v, i.e. it returns the last arc of a
 		    ///shortest path from a root to \c v. It is \c INVALID if \c v
 		    ///is not reached from the root(s) or if \c v is a root.
 		    ///
 		    ///The shortest path tree used here is equal to the shortest path
 		    ///tree used in \ref predNode() and \ref predMap().
 		    ///
 		    ///\pre Either \ref run(Node) "run()" or \ref init()
 		    ///must be called before using this function.
 		    Arc predArc(Node v) const { return (*_pred)[v]; }

lemon/dim2.h

Show inline comments

 		/* -*- mode: C++; indent-tabs-mode: nil; -*-
+		 *
 		 * This file is a part of LEMON, a generic C++ optimization library.
+		 *
 		 * 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_DIM2_H
 		#define LEMON_DIM2_H
 		#include <iostream>
-		///\ingroup misc
+		///\ingroup geomdat
 		///\file
 		///\brief A simple two dimensional vector and a bounding box implementation
 		///
 		/// The class \ref lemon::dim2::Point "dim2::Point" implements
 		/// a two dimensional vector with the usual operations.
 		///
 		/// The class \ref lemon::dim2::Box "dim2::Box" can be used to determine
 		/// the rectangular bounding box of a set of
 		/// \ref lemon::dim2::Point "dim2::Point"'s.
 		namespace lemon {
 		  ///Tools for handling two dimensional coordinates
 		  ///This namespace is a storage of several
 		  ///tools for handling two dimensional coordinates
 		  namespace dim2 {
-		  /// \addtogroup misc
+		  /// \addtogroup geomdat
 		  /// @{
 		  /// Two dimensional vector (plain vector)
 		  /// A simple two dimensional vector (plain vector) implementation
 		  /// with the usual vector operations.
 		  template<typename T>
 		    class Point {
 		    public:
 		      typedef T Value;
 		      ///First coordinate
 		      T x;
 		      ///Second coordinate
 		      T y;
 		      ///Default constructor
 		      Point() {}
 		      ///Construct an instance from coordinates
 		      Point(T a, T b) : x(a), y(b) { }
 		      ///Returns the dimension of the vector (i.e. returns 2).
 		      ///The dimension of the vector.
 		      ///This function always returns 2.
 		      int size() const { return 2; }
 		      ///Subscripting operator
 		      ///\c p[0] is \c p.x and \c p[1] is \c p.y
 		      ///
 		      T& operator[](int idx) { return idx == 0 ? x : y; }
 		      ///Const subscripting operator
 		      ///\c p[0] is \c p.x and \c p[1] is \c p.y
 		      ///
 		      const T& operator[](int idx) const { return idx == 0 ? x : y; }
 		      ///Conversion constructor
 		      template<class TT> Point(const Point<TT> &p) : x(p.x), y(p.y) {}
 		      ///Give back the square of the norm of the vector
 		      T normSquare() const {
 		        return x*x+y*y;
+		      }
 		      ///Increment the left hand side by \c u
 		      Point<T>& operator +=(const Point<T>& u) {
 		        x += u.x;
 		        y += u.y;
 		        return *this;
+		      }
 		      ///Decrement the left hand side by \c u
 		      Point<T>& operator -=(const Point<T>& u) {
 		        x -= u.x;
 		        y -= u.y;
 		        return *this;
+		      }
 		      ///Multiply the left hand side with a scalar
 		      Point<T>& operator *=(const T &u) {
 		        x *= u;
 		        y *= u;
 		        return *this;
+		      }
 		      ///Divide the left hand side by a scalar
 		      Point<T>& operator /=(const T &u) {
 		        x /= u;
 		        y /= u;
 		        return *this;
+		      }
 		      ///Return the scalar product of two vectors
 		      T operator *(const Point<T>& u) const {
 		        return x*u.x+y*u.y;
+		      }
 		      ///Return the sum of two vectors
 		      Point<T> operator+(const Point<T> &u) const {
 		        Point<T> b=*this;
 		        return b+=u;
+		      }
 		      ///Return the negative of the vector
 		      Point<T> operator-() const {
 		        Point<T> b=*this;
 		        b.x=-b.x; b.y=-b.y;
 		        return b;
+		      }
 		      ///Return the difference of two vectors
 		      Point<T> operator-(const Point<T> &u) const {
 		        Point<T> b=*this;
 		        return b-=u;
+		      }
 		      ///Return a vector multiplied by a scalar
 		      Point<T> operator*(const T &u) const {
 		        Point<T> b=*this;
 		        return b*=u;
+		      }
 		      ///Return a vector divided by a scalar
 		      Point<T> operator/(const T &u) const {
 		        Point<T> b=*this;
 		        return b/=u;
+		      }
 		      ///Test equality
 		      bool operator==(const Point<T> &u) const {
 		        return (x==u.x) && (y==u.y);
+		      }
 		      ///Test inequality
 		      bool operator!=(Point u) const {
 		        return  (x!=u.x) || (y!=u.y);
+		      }
 		    };
 		  ///Return a Point
 		  ///Return a Point.
 		  ///\relates Point
 		  template <typename T>
 		  inline Point<T> makePoint(const T& x, const T& y) {
 		    return Point<T>(x, y);
+		  }
 		  ///Return a vector multiplied by a scalar
 		  ///Return a vector multiplied by a scalar.
 		  ///\relates Point
 		  template<typename T> Point<T> operator*(const T &u,const Point<T> &x) {
 		    return x*u;
+		  }
 		  ///Read a plain vector from a stream
 		  ///Read a plain vector from a stream.
 		  ///\relates Point
 		  ///
 		  template<typename T>
 		  inline std::istream& operator>>(std::istream &is, Point<T> &z) {
 		    char c;
 		    if (is >> c) {
 		      if (c != '(') is.putback(c);
 		    } else {
 		      is.clear();
+		    }
 		    if (!(is >> z.x)) return is;
 		    if (is >> c) {
 		      if (c != ',') is.putback(c);
 		    } else {
 		      is.clear();
+		    }
 		    if (!(is >> z.y)) return is;
 		    if (is >> c) {
 		      if (c != ')') is.putback(c);
 		    } else {
 		      is.clear();
+		    }
 		    return is;
+		  }
 		  ///Write a plain vector to a stream
 		  ///Write a plain vector to a stream.
 		  ///\relates Point
 		  ///
 		  template<typename T>
 		  inline std::ostream& operator<<(std::ostream &os, const Point<T>& z)
+		  {
 		    os << "(" << z.x << "," << z.y << ")";
 		    return os;
+		  }
 		  ///Rotate by 90 degrees
 		  ///Returns the parameter rotated by 90 degrees in positive direction.
 		  ///\relates Point
 		  ///
 		  template<typename T>
 		  inline Point<T> rot90(const Point<T> &z)
+		  {
 		    return Point<T>(-z.y,z.x);
+		  }
 		  ///Rotate by 180 degrees
 		  ///Returns the parameter rotated by 180 degrees.
 		  ///\relates Point
 		  ///
 		  template<typename T>
 		  inline Point<T> rot180(const Point<T> &z)
+		  {
 		    return Point<T>(-z.x,-z.y);
+		  }
 		  ///Rotate by 270 degrees
 		  ///Returns the parameter rotated by 90 degrees in negative direction.
 		  ///\relates Point
 		  ///
 		  template<typename T>
 		  inline Point<T> rot270(const Point<T> &z)
+		  {
 		    return Point<T>(z.y,-z.x);
+		  }
 		  /// Bounding box of plain vectors (points).
 		  /// A class to calculate or store the bounding box of plain vectors
 		  /// (\ref Point "points").
 		  template<typename T>
 		  class Box {
 		      Point<T> _bottom_left, _top_right;
 		      bool _empty;
 		    public:
 		      ///Default constructor: creates an empty box
 		      Box() { _empty = true; }
 		      ///Construct a box from one point
 		      Box(Point<T> a) {
 		        _bottom_left = _top_right = a;
 		        _empty = false;
+		      }
 		      ///Construct a box from two points
 		      ///Construct a box from two points.
 		      ///\param a The bottom left corner.
 		      ///\param b The top right corner.
 		      ///\warning The coordinates of the bottom left corner must be no more
 		      ///than those of the top right one.
 		      Box(Point<T> a,Point<T> b)
+		      {
 		        _bottom_left = a;
 		        _top_right = b;
 		        _empty = false;
+		      }
 		      ///Construct a box from four numbers
 		      ///Construct a box from four numbers.
 		      ///\param l The left side of the box.
 		      ///\param b The bottom of the box.

lemon/gomory_hu.h

Show inline comments

@@ -106,465 +106,465 @@
 		      if (_weight) {
 			delete _weight;
+		      }
 		      if (_order) {
 			delete _order;
+		      }
+		    }
 		  public:
 		    /// \brief Constructor
 		    ///
 		    /// Constructor.
 		    /// \param graph The undirected graph the algorithm runs on.
 		    /// \param capacity The edge capacity map.
 		    GomoryHu(const Graph& graph, const Capacity& capacity)
 		      : _graph(graph), _capacity(capacity),
 			_pred(0), _weight(0), _order(0)
+		    {
 		      checkConcept<concepts::ReadMap<Edge, Value>, Capacity>();
+		    }
 		    /// \brief Destructor
 		    ///
 		    /// Destructor.
 		    ~GomoryHu() {
 		      destroyStructures();
+		    }
 		  private:
 		    // Initialize the internal data structures
 		    void init() {
 		      createStructures();
 		      _root = NodeIt(_graph);
 		      for (NodeIt n(_graph); n != INVALID; ++n) {
 		        (*_pred)[n] = _root;
 		        (*_order)[n] = -1;
+		      }
 		      (*_pred)[_root] = INVALID;
 		      (*_weight)[_root] = std::numeric_limits<Value>::max();
+		    }
 		    // Start the algorithm
 		    void start() {
 		      Preflow<Graph, Capacity> fa(_graph, _capacity, _root, INVALID);
 		      for (NodeIt n(_graph); n != INVALID; ++n) {
 			if (n == _root) continue;
 			Node pn = (*_pred)[n];
 			fa.source(n);
 			fa.target(pn);
 			fa.runMinCut();
 			(*_weight)[n] = fa.flowValue();
 			for (NodeIt nn(_graph); nn != INVALID; ++nn) {
 			  if (nn != n && fa.minCut(nn) && (*_pred)[nn] == pn) {
 			    (*_pred)[nn] = n;
+			  }
+			}
 			if ((*_pred)[pn] != INVALID && fa.minCut((*_pred)[pn])) {
 			  (*_pred)[n] = (*_pred)[pn];
 			  (*_pred)[pn] = n;
 			  (*_weight)[n] = (*_weight)[pn];
 			  (*_weight)[pn] = fa.flowValue();
+			}
+		      }
 		      (*_order)[_root] = 0;
 		      int index = 1;
 		      for (NodeIt n(_graph); n != INVALID; ++n) {
 			std::vector<Node> st;
 			Node nn = n;
 			while ((*_order)[nn] == -1) {
 			  st.push_back(nn);
 			  nn = (*_pred)[nn];
+			}
 			while (!st.empty()) {
 			  (*_order)[st.back()] = index++;
 			  st.pop_back();
+			}
+		      }
+		    }
 		  public:
 		    ///\name Execution Control
 		    ///@{
 		    /// \brief Run the Gomory-Hu algorithm.
 		    ///
 		    /// This function runs the Gomory-Hu algorithm.
 		    void run() {
 		      init();
 		      start();
+		    }
 		    /// @}
 		    ///\name Query Functions
 		    ///The results of the algorithm can be obtained using these
 		    ///functions.\n
 		    ///\ref run() should be called before using them.\n
 		    ///See also \ref MinCutNodeIt and \ref MinCutEdgeIt.
 		    ///@{
 		    /// \brief Return the predecessor node in the Gomory-Hu tree.
 		    ///
 		    /// This function returns the predecessor node of the given node
 		    /// in the Gomory-Hu tree.
 		    /// If \c node is the root of the tree, then it returns \c INVALID.
 		    ///
 		    /// \pre \ref run() must be called before using this function.
 		    Node predNode(const Node& node) const {
 		      return (*_pred)[node];
+		    }
 		    /// \brief Return the weight of the predecessor edge in the
 		    /// Gomory-Hu tree.
 		    ///
 		    /// This function returns the weight of the predecessor edge of the
 		    /// given node in the Gomory-Hu tree.
 		    /// If \c node is the root of the tree, the result is undefined.
 		    ///
 		    /// \pre \ref run() must be called before using this function.
 		    Value predValue(const Node& node) const {
 		      return (*_weight)[node];
+		    }
 		    /// \brief Return the distance from the root node in the Gomory-Hu tree.
 		    ///
 		    /// This function returns the distance of the given node from the root
 		    /// node in the Gomory-Hu tree.
 		    ///
 		    /// \pre \ref run() must be called before using this function.
 		    int rootDist(const Node& node) const {
 		      return (*_order)[node];
+		    }
 		    /// \brief Return the minimum cut value between two nodes
 		    ///
 		    /// This function returns the minimum cut value between the nodes
 		    /// \c s and \c t.
 		    /// It finds the nearest common ancestor of the given nodes in the
 		    /// Gomory-Hu tree and calculates the minimum weight edge on the
 		    /// paths to the ancestor.
 		    ///
 		    /// \pre \ref run() must be called before using this function.
 		    Value minCutValue(const Node& s, const Node& t) const {
 		      Node sn = s, tn = t;
 		      Value value = std::numeric_limits<Value>::max();
 		      while (sn != tn) {
 			if ((*_order)[sn] < (*_order)[tn]) {
 			  if ((*_weight)[tn] <= value) value = (*_weight)[tn];
 			  tn = (*_pred)[tn];
 			} else {
 			  if ((*_weight)[sn] <= value) value = (*_weight)[sn];
 			  sn = (*_pred)[sn];
+			}
+		      }
 		      return value;
+		    }
 		    /// \brief Return the minimum cut between two nodes
 		    ///
 		    /// This function returns the minimum cut between the nodes \c s and \c t
 		    /// in the \c cutMap parameter by setting the nodes in the component of
 		    /// \c s to \c true and the other nodes to \c false.
 		    ///
 		    /// For higher level interfaces see MinCutNodeIt and MinCutEdgeIt.
 		    ///
 		    /// \param s The base node.
 		    /// \param t The node you want to separate from node \c s.
 		    /// \param cutMap The cut will be returned in this map.
 		    /// It must be a \c bool (or convertible) \ref concepts::ReadWriteMap
 		    /// "ReadWriteMap" on the graph nodes.
 		    ///
 		    /// \return The value of the minimum cut between \c s and \c t.
 		    ///
 		    /// \pre \ref run() must be called before using this function.
 		    template <typename CutMap>
 		    Value minCutMap(const Node& s, ///<
 		                    const Node& t,
 		                    ///<
 		                    CutMap& cutMap
 		                    ///<
 		                    ) const {
 		      Node sn = s, tn = t;
 		      bool s_root=false;
 		      Node rn = INVALID;
 		      Value value = std::numeric_limits<Value>::max();
 		      while (sn != tn) {
 			if ((*_order)[sn] < (*_order)[tn]) {
 			  if ((*_weight)[tn] <= value) {
 			    rn = tn;
 		            s_root = false;
 			    value = (*_weight)[tn];
+			  }
 			  tn = (*_pred)[tn];
 			} else {
 			  if ((*_weight)[sn] <= value) {
 			    rn = sn;
 		            s_root = true;
 			    value = (*_weight)[sn];
+			  }
 			  sn = (*_pred)[sn];
+			}
+		      }
 		      typename Graph::template NodeMap<bool> reached(_graph, false);
 		      reached[_root] = true;
 		      cutMap.set(_root, !s_root);
 		      reached[rn] = true;
 		      cutMap.set(rn, s_root);
 		      std::vector<Node> st;
 		      for (NodeIt n(_graph); n != INVALID; ++n) {
 			st.clear();
 		        Node nn = n;
 			while (!reached[nn]) {
 			  st.push_back(nn);
 			  nn = (*_pred)[nn];
+			}
 			while (!st.empty()) {
 			  cutMap.set(st.back(), cutMap[nn]);
 			  st.pop_back();
+			}
+		      }
 		      return value;
+		    }
 		    ///@}
 		    friend class MinCutNodeIt;
 		    /// Iterate on the nodes of a minimum cut
 		    /// This iterator class lists the nodes of a minimum cut found by
 		    /// GomoryHu. Before using it, you must allocate a GomoryHu class
 		    /// and call its \ref GomoryHu::run() "run()" method.
 		    ///
 		    /// This example counts the nodes in the minimum cut separating \c s from
 		    /// \c t.
 		    /// \code
-		    /// GomoruHu<Graph> gom(g, capacities);
+		    /// GomoryHu<Graph> gom(g, capacities);
 		    /// gom.run();
 		    /// int cnt=0;
-		    /// for(GomoruHu<Graph>::MinCutNodeIt n(gom,s,t); n!=INVALID; ++n) ++cnt;
+		    /// for(GomoryHu<Graph>::MinCutNodeIt n(gom,s,t); n!=INVALID; ++n) ++cnt;
 		    /// \endcode
 		    class MinCutNodeIt
+		    {
 		      bool _side;
 		      typename Graph::NodeIt _node_it;
 		      typename Graph::template NodeMap<bool> _cut;
 		    public:
 		      /// Constructor
 		      /// Constructor.
 		      ///
 		      MinCutNodeIt(GomoryHu const &gomory,
 		                   ///< The GomoryHu class. You must call its
 		                   ///  run() method
 		                   ///  before initializing this iterator.
 		                   const Node& s, ///< The base node.
 		                   const Node& t,
 		                   ///< The node you want to separate from node \c s.
 		                   bool side=true
 		                   ///< If it is \c true (default) then the iterator lists
 		                   ///  the nodes of the component containing \c s,
 		                   ///  otherwise it lists the other component.
 		                   /// \note As the minimum cut is not always unique,
 		                   /// \code
 		                   /// MinCutNodeIt(gomory, s, t, true);
 		                   /// \endcode
 		                   /// and
 		                   /// \code
 		                   /// MinCutNodeIt(gomory, t, s, false);
 		                   /// \endcode
 		                   /// does not necessarily give the same set of nodes.
 		                   /// However it is ensured that
 		                   /// \code
 		                   /// MinCutNodeIt(gomory, s, t, true);
 		                   /// \endcode
 		                   /// and
 		                   /// \code
 		                   /// MinCutNodeIt(gomory, s, t, false);
 		                   /// \endcode
 		                   /// together list each node exactly once.
+		                   )
 		        : _side(side), _cut(gomory._graph)
+		      {
 		        gomory.minCutMap(s,t,_cut);
 		        for(_node_it=typename Graph::NodeIt(gomory._graph);
 		            _node_it!=INVALID && _cut[_node_it]!=_side;
 		            ++_node_it) {}
+		      }
 		      /// Conversion to \c Node
 		      /// Conversion to \c Node.
 		      ///
 		      operator typename Graph::Node() const
+		      {
 		        return _node_it;
+		      }
 		      bool operator==(Invalid) { return _node_it==INVALID; }
 		      bool operator!=(Invalid) { return _node_it!=INVALID; }
 		      /// Next node
 		      /// Next node.
 		      ///
 		      MinCutNodeIt &operator++()
+		      {
 		        for(++_node_it;_node_it!=INVALID&&_cut[_node_it]!=_side;++_node_it) {}
 		        return *this;
+		      }
 		      /// Postfix incrementation
 		      /// Postfix incrementation.
 		      ///
 		      /// \warning This incrementation
 		      /// returns a \c Node, not a \c MinCutNodeIt, as one may
 		      /// expect.
 		      typename Graph::Node operator++(int)
+		      {
 		        typename Graph::Node n=*this;
 		        ++(*this);
 		        return n;
+		      }
 		    };
 		    friend class MinCutEdgeIt;
 		    /// Iterate on the edges of a minimum cut
 		    /// This iterator class lists the edges of a minimum cut found by
 		    /// GomoryHu. Before using it, you must allocate a GomoryHu class
 		    /// and call its \ref GomoryHu::run() "run()" method.
 		    ///
 		    /// This example computes the value of the minimum cut separating \c s from
 		    /// \c t.
 		    /// \code
-		    /// GomoruHu<Graph> gom(g, capacities);
+		    /// GomoryHu<Graph> gom(g, capacities);
 		    /// gom.run();
 		    /// int value=0;
-		    /// for(GomoruHu<Graph>::MinCutEdgeIt e(gom,s,t); e!=INVALID; ++e)
+		    /// for(GomoryHu<Graph>::MinCutEdgeIt e(gom,s,t); e!=INVALID; ++e)
 		    ///   value+=capacities[e];
 		    /// \endcode
 		    /// The result will be the same as the value returned by
 		    /// \ref GomoryHu::minCutValue() "gom.minCutValue(s,t)".
 		    class MinCutEdgeIt
+		    {
 		      bool _side;
 		      const Graph &_graph;
 		      typename Graph::NodeIt _node_it;
 		      typename Graph::OutArcIt _arc_it;
 		      typename Graph::template NodeMap<bool> _cut;
 		      void step()
+		      {
 		        ++_arc_it;
 		        while(_node_it!=INVALID && _arc_it==INVALID)
+		          {
 		            for(++_node_it;_node_it!=INVALID&&!_cut[_node_it];++_node_it) {}
 		            if(_node_it!=INVALID)
 		              _arc_it=typename Graph::OutArcIt(_graph,_node_it);
+		          }
+		      }
 		    public:
 		      /// Constructor
 		      /// Constructor.
 		      ///
 		      MinCutEdgeIt(GomoryHu const &gomory,
 		                   ///< The GomoryHu class. You must call its
 		                   ///  run() method
 		                   ///  before initializing this iterator.
 		                   const Node& s,  ///< The base node.
 		                   const Node& t,
 		                   ///< The node you want to separate from node \c s.
 		                   bool side=true
 		                   ///< If it is \c true (default) then the listed arcs
 		                   ///  will be oriented from the
 		                   ///  nodes of the component containing \c s,
 		                   ///  otherwise they will be oriented in the opposite
 		                   ///  direction.
+		                   )
 		        : _graph(gomory._graph), _cut(_graph)
+		      {
 		        gomory.minCutMap(s,t,_cut);
 		        if(!side)
 		          for(typename Graph::NodeIt n(_graph);n!=INVALID;++n)
 		            _cut[n]=!_cut[n];
 		        for(_node_it=typename Graph::NodeIt(_graph);
 		            _node_it!=INVALID && !_cut[_node_it];
 		            ++_node_it) {}
 		        _arc_it = _node_it!=INVALID ?
 		          typename Graph::OutArcIt(_graph,_node_it) : INVALID;
 		        while(_node_it!=INVALID && _arc_it == INVALID)
+		          {
 		            for(++_node_it; _node_it!=INVALID&&!_cut[_node_it]; ++_node_it) {}
 		            if(_node_it!=INVALID)
 		              _arc_it= typename Graph::OutArcIt(_graph,_node_it);
+		          }
 		        while(_arc_it!=INVALID && _cut[_graph.target(_arc_it)]) step();
+		      }
 		      /// Conversion to \c Arc
 		      /// Conversion to \c Arc.
 		      ///
 		      operator typename Graph::Arc() const
+		      {
 		        return _arc_it;
+		      }
 		      /// Conversion to \c Edge
 		      /// Conversion to \c Edge.
 		      ///
 		      operator typename Graph::Edge() const
+		      {
 		        return _arc_it;
+		      }
 		      bool operator==(Invalid) { return _node_it==INVALID; }
 		      bool operator!=(Invalid) { return _node_it!=INVALID; }
 		      /// Next edge
 		      /// Next edge.
 		      ///
 		      MinCutEdgeIt &operator++()
+		      {
 		        step();
 		        while(_arc_it!=INVALID && _cut[_graph.target(_arc_it)]) step();
 		        return *this;
+		      }
 		      /// Postfix incrementation
 		      /// Postfix incrementation.
 		      ///
 		      /// \warning This incrementation
 		      /// returns an \c Arc, not a \c MinCutEdgeIt, as one may expect.
 		      typename Graph::Arc operator++(int)
+		      {
 		        typename Graph::Arc e=*this;
 		        ++(*this);
 		        return e;
+		      }
 		    };
 		  };
+		}
 		#endif

lemon/maps.h

Show inline comments

 		/* -*- mode: C++; indent-tabs-mode: nil; -*-
+		 *
 		 * This file is a part of LEMON, a generic C++ optimization library.
+		 *
 		 * 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_MAPS_H
 		#define LEMON_MAPS_H
 		#include <iterator>
 		#include <functional>
 		#include <vector>
 		#include <map>
 		#include <lemon/core.h>
 		///\file
 		///\ingroup maps
 		///\brief Miscellaneous property maps
 		#include <map>
 		namespace lemon {
 		  /// \addtogroup maps
 		  /// @{
 		  /// Base class of maps.
 		  /// Base class of maps. It provides the necessary type definitions
 		  /// required by the map %concepts.
 		  template<typename K, typename V>
 		  class MapBase {
 		  public:
 		    /// \brief The key type of the map.
 		    typedef K Key;
 		    /// \brief The value type of the map.
 		    /// (The type of objects associated with the keys).
 		    typedef V Value;
 		  };
 		  /// Null map. (a.k.a. DoNothingMap)
 		  /// This map can be used if you have to provide a map only for
 		  /// its type definitions, or if you have to provide a writable map,
 		  /// but data written to it is not required (i.e. it will be sent to
 		  /// <tt>/dev/null</tt>).
 		  /// It conforms the \ref concepts::ReadWriteMap "ReadWriteMap" concept.
 		  ///
 		  /// \sa ConstMap
 		  template<typename K, typename V>
 		  class NullMap : public MapBase<K, V> {
 		  public:
 		    ///\e
 		    typedef K Key;
 		    ///\e
 		    typedef V Value;
 		    /// Gives back a default constructed element.
 		    Value operator[](const Key&) const { return Value(); }
 		    /// Absorbs the value.
 		    void set(const Key&, const Value&) {}
 		  };
 		  /// Returns a \c NullMap class
 		  /// This function just returns a \c NullMap class.
 		  /// \relates NullMap
 		  template <typename K, typename V>
 		  NullMap<K, V> nullMap() {
 		    return NullMap<K, V>();
+		  }
 		  /// Constant map.
 		  /// This \ref concepts::ReadMap "readable map" assigns a specified
 		  /// value to each key.
 		  ///
 		  /// In other aspects it is equivalent to \c NullMap.
 		  /// So it conforms the \ref concepts::ReadWriteMap "ReadWriteMap"
 		  /// concept, but it absorbs the data written to it.
 		  ///
 		  /// The simplest way of using this map is through the constMap()
 		  /// function.
 		  ///
 		  /// \sa NullMap
 		  /// \sa IdentityMap
 		  template<typename K, typename V>
 		  class ConstMap : public MapBase<K, V> {
 		  private:
 		    V _value;
 		  public:
 		    ///\e
 		    typedef K Key;
 		    ///\e
 		    typedef V Value;
 		    /// Default constructor
 		    /// Default constructor.
 		    /// The value of the map will be default constructed.
 		    ConstMap() {}
 		    /// Constructor with specified initial value
 		    /// Constructor with specified initial value.
 		    /// \param v The initial value of the map.
 		    ConstMap(const Value &v) : _value(v) {}
 		    /// Gives back the specified value.
 		    Value operator[](const Key&) const { return _value; }
 		    /// Absorbs the value.
 		    void set(const Key&, const Value&) {}
 		    /// Sets the value that is assigned to each key.
 		    void setAll(const Value &v) {
 		      _value = v;
+		    }
 		    template<typename V1>
 		    ConstMap(const ConstMap<K, V1> &, const Value &v) : _value(v) {}
 		  };
 		  /// Returns a \c ConstMap class
 		  /// This function just returns a \c ConstMap class.
 		  /// \relates ConstMap
 		  template<typename K, typename V>
 		  inline ConstMap<K, V> constMap(const V &v) {
 		    return ConstMap<K, V>(v);
+		  }
 		  template<typename K, typename V>
 		  inline ConstMap<K, V> constMap() {
 		    return ConstMap<K, V>();
+		  }
 		  template<typename T, T v>
 		  struct Const {};
 		  /// Constant map with inlined constant value.
 		  /// This \ref concepts::ReadMap "readable map" assigns a specified
 		  /// value to each key.
 		  ///
 		  /// In other aspects it is equivalent to \c NullMap.
 		  /// So it conforms the \ref concepts::ReadWriteMap "ReadWriteMap"
 		  /// concept, but it absorbs the data written to it.
 		  ///
 		  /// The simplest way of using this map is through the constMap()
 		  /// function.
 		  ///
 		  /// \sa NullMap
 		  /// \sa IdentityMap
 		  template<typename K, typename V, V v>
 		  class ConstMap<K, Const<V, v> > : public MapBase<K, V> {
 		  public:
 		    ///\e
 		    typedef K Key;
 		    ///\e
 		    typedef V Value;
 		    /// Constructor.
 		    ConstMap() {}
 		    /// Gives back the specified value.
 		    Value operator[](const Key&) const { return v; }
 		    /// Absorbs the value.
 		    void set(const Key&, const Value&) {}
 		  };
 		  /// Returns a \c ConstMap class with inlined constant value
 		  /// This function just returns a \c ConstMap class with inlined
 		  /// constant value.
 		  /// \relates ConstMap
 		  template<typename K, typename V, V v>
 		  inline ConstMap<K, Const<V, v> > constMap() {
 		    return ConstMap<K, Const<V, v> >();
+		  }
 		  /// Identity map.
 		  /// This \ref concepts::ReadMap "read-only map" gives back the given
 		  /// key as value without any modification.
 		  ///
 		  /// \sa ConstMap
 		  template <typename T>
 		  class IdentityMap : public MapBase<T, T> {
 		  public:
 		    ///\e
 		    typedef T Key;
 		    ///\e
 		    typedef T Value;
 		    /// Gives back the given value without any modification.
 		    Value operator[](const Key &k) const {
 		      return k;
+		    }
 		  };
 		  /// Returns an \c IdentityMap class
 		  /// This function just returns an \c IdentityMap class.
 		  /// \relates IdentityMap
 		  template<typename T>
 		  inline IdentityMap<T> identityMap() {
 		    return IdentityMap<T>();
+		  }
 		  /// \brief Map for storing values for integer keys from the range
 		  /// <tt>[0..size-1]</tt>.
 		  ///
 		  /// This map is essentially a wrapper for \c std::vector. It assigns
 		  /// values to integer keys from the range <tt>[0..size-1]</tt>.
 		  /// It can be used with some data structures, for example
 		  /// \c UnionFind, \c BinHeap, when the used items are small
 		  /// integers. This map conforms the \ref concepts::ReferenceMap
 		  /// "ReferenceMap" concept.
 		  ///
 		  /// The simplest way of using this map is through the rangeMap()
 		  /// function.
 		  template <typename V>
 		  class RangeMap : public MapBase<int, V> {
 		    template <typename V1>
 		    friend class RangeMap;
 		  private:
 		    typedef std::vector<V> Vector;
 		    Vector _vector;
 		  public:
 		    /// Key type
 		    typedef int Key;
 		    /// Value type
 		    typedef V Value;
 		    /// Reference type
 		    typedef typename Vector::reference Reference;
 		    /// Const reference type
 		    typedef typename Vector::const_reference ConstReference;
 		    typedef True ReferenceMapTag;
 		  public:
 		    /// Constructor with specified default value.
 		    RangeMap(int size = 0, const Value &value = Value())
 		      : _vector(size, value) {}
 		    /// Constructs the map from an appropriate \c std::vector.
 		    template <typename V1>
 		    RangeMap(const std::vector<V1>& vector)
 		      : _vector(vector.begin(), vector.end()) {}
 		    /// Constructs the map from another \c RangeMap.
 		    template <typename V1>
 		    RangeMap(const RangeMap<V1> &c)
 		      : _vector(c._vector.begin(), c._vector.end()) {}
 		    /// Returns the size of the map.
 		    int size() {
 		      return _vector.size();
+		    }
 		    /// Resizes the map.
 		    /// Resizes the underlying \c std::vector container, so changes the
 		    /// keyset of the map.
 		    /// \param size The new size of the map. The new keyset will be the
 		    /// range <tt>[0..size-1]</tt>.
@@ -1565,1223 +1564,2139 @@
 		    NotWriteMap(M &m) : _m(m) {}
 		    ///\e
 		    Value operator[](const Key &k) const { return !_m[k]; }
 		    ///\e
 		    void set(const Key &k, bool v) { _m.set(k, !v); }
 		  };
 		  /// Returns a \c NotMap class
 		  /// This function just returns a \c NotMap class.
 		  ///
 		  /// For example, if \c m is a map with \c bool values, then
 		  /// <tt>notMap(m)[x]</tt> will be equal to <tt>!m[x]</tt>.
 		  ///
 		  /// \relates NotMap
 		  template <typename M>
 		  inline NotMap<M> notMap(const M &m) {
 		    return NotMap<M>(m);
+		  }
 		  /// Returns a \c NotWriteMap class
 		  /// This function just returns a \c NotWriteMap class.
 		  ///
 		  /// For example, if \c m is a map with \c bool values, then
 		  /// <tt>notWriteMap(m)[x]</tt> will be equal to <tt>!m[x]</tt>.
 		  /// Moreover it makes also possible to write the map.
 		  ///
 		  /// \relates NotWriteMap
 		  template <typename M>
 		  inline NotWriteMap<M> notWriteMap(M &m) {
 		    return NotWriteMap<M>(m);
+		  }
 		  /// Combination of two maps using the \c == operator
 		  /// This \ref concepts::ReadMap "read-only map" assigns \c true to
 		  /// the keys for which the corresponding values of the two maps are
 		  /// equal.
 		  /// Its \c Key type is inherited from \c M1 and its \c Value type is
 		  /// \c bool. \c M2::Key must be convertible to \c M1::Key.
 		  ///
 		  /// If \c m1 is of type \c M1 and \c m2 is of \c M2, then for
 		  /// \code
 		  ///   EqualMap<M1,M2> em(m1,m2);
 		  /// \endcode
 		  /// <tt>em[x]</tt> will be equal to <tt>m1[x]==m2[x]</tt>.
 		  ///
 		  /// The simplest way of using this map is through the equalMap()
 		  /// function.
 		  ///
 		  /// \sa LessMap
 		  template<typename M1, typename M2>
 		  class EqualMap : public MapBase<typename M1::Key, bool> {
 		    const M1 &_m1;
 		    const M2 &_m2;
 		  public:
 		    ///\e
 		    typedef typename M1::Key Key;
 		    ///\e
 		    typedef bool Value;
 		    /// Constructor
 		    EqualMap(const M1 &m1, const M2 &m2) : _m1(m1), _m2(m2) {}
 		    ///\e
 		    Value operator[](const Key &k) const { return _m1[k]==_m2[k]; }
 		  };
 		  /// Returns an \c EqualMap class
 		  /// This function just returns an \c EqualMap class.
 		  ///
 		  /// For example, if \c m1 and \c m2 are maps with keys and values of
 		  /// the same type, then <tt>equalMap(m1,m2)[x]</tt> will be equal to
 		  /// <tt>m1[x]==m2[x]</tt>.
 		  ///
 		  /// \relates EqualMap
 		  template<typename M1, typename M2>
 		  inline EqualMap<M1, M2> equalMap(const M1 &m1, const M2 &m2) {
 		    return EqualMap<M1, M2>(m1,m2);
+		  }
 		  /// Combination of two maps using the \c < operator
 		  /// This \ref concepts::ReadMap "read-only map" assigns \c true to
 		  /// the keys for which the corresponding value of the first map is
 		  /// less then the value of the second map.
 		  /// Its \c Key type is inherited from \c M1 and its \c Value type is
 		  /// \c bool. \c M2::Key must be convertible to \c M1::Key.
 		  ///
 		  /// If \c m1 is of type \c M1 and \c m2 is of \c M2, then for
 		  /// \code
 		  ///   LessMap<M1,M2> lm(m1,m2);
 		  /// \endcode
 		  /// <tt>lm[x]</tt> will be equal to <tt>m1[x]<m2[x]</tt>.
 		  ///
 		  /// The simplest way of using this map is through the lessMap()
 		  /// function.
 		  ///
 		  /// \sa EqualMap
 		  template<typename M1, typename M2>
 		  class LessMap : public MapBase<typename M1::Key, bool> {
 		    const M1 &_m1;
 		    const M2 &_m2;
 		  public:
 		    ///\e
 		    typedef typename M1::Key Key;
 		    ///\e
 		    typedef bool Value;
 		    /// Constructor
 		    LessMap(const M1 &m1, const M2 &m2) : _m1(m1), _m2(m2) {}
 		    ///\e
 		    Value operator[](const Key &k) const { return _m1[k]<_m2[k]; }
 		  };
 		  /// Returns an \c LessMap class
 		  /// This function just returns an \c LessMap class.
 		  ///
 		  /// For example, if \c m1 and \c m2 are maps with keys and values of
 		  /// the same type, then <tt>lessMap(m1,m2)[x]</tt> will be equal to
 		  /// <tt>m1[x]<m2[x]</tt>.
 		  ///
 		  /// \relates LessMap
 		  template<typename M1, typename M2>
 		  inline LessMap<M1, M2> lessMap(const M1 &m1, const M2 &m2) {
 		    return LessMap<M1, M2>(m1,m2);
+		  }
 		  namespace _maps_bits {
 		    template <typename _Iterator, typename Enable = void>
 		    struct IteratorTraits {
 		      typedef typename std::iterator_traits<_Iterator>::value_type Value;
 		    };
 		    template <typename _Iterator>
 		    struct IteratorTraits<_Iterator,
 		      typename exists<typename _Iterator::container_type>::type>
+		    {
 		      typedef typename _Iterator::container_type::value_type Value;
 		    };
+		  }
 		  /// @}
 		  /// \addtogroup maps
 		  /// @{
 		  /// \brief Writable bool map for logging each \c true assigned element
 		  ///
 		  /// A \ref concepts::WriteMap "writable" bool map for logging
 		  /// each \c true assigned element, i.e it copies subsequently each
 		  /// keys set to \c true to the given iterator.
 		  /// The most important usage of it is storing certain nodes or arcs
 		  /// that were marked \c true by an algorithm.
 		  ///
 		  /// There are several algorithms that provide solutions through bool
 		  /// maps and most of them assign \c true at most once for each key.
 		  /// In these cases it is a natural request to store each \c true
 		  /// assigned elements (in order of the assignment), which can be
 		  /// easily done with LoggerBoolMap.
 		  ///
 		  /// The simplest way of using this map is through the loggerBoolMap()
 		  /// function.
 		  ///
 		  /// \tparam IT The type of the iterator.
 		  /// \tparam KEY The key type of the map. The default value set
 		  /// according to the iterator type should work in most cases.
 		  ///
 		  /// \note The container of the iterator must contain enough space
 		  /// for the elements or the iterator should be an inserter iterator.
 		#ifdef DOXYGEN
 		  template <typename IT, typename KEY>
 		#else
 		  template <typename IT,
 		            typename KEY = typename _maps_bits::IteratorTraits<IT>::Value>
 		#endif
 		  class LoggerBoolMap : public MapBase<KEY, bool> {
 		  public:
 		    ///\e
 		    typedef KEY Key;
 		    ///\e
 		    typedef bool Value;
 		    ///\e
 		    typedef IT Iterator;
 		    /// Constructor
 		    LoggerBoolMap(Iterator it)
 		      : _begin(it), _end(it) {}
 		    /// Gives back the given iterator set for the first key
 		    Iterator begin() const {
 		      return _begin;
+		    }
 		    /// Gives back the the 'after the last' iterator
 		    Iterator end() const {
 		      return _end;
+		    }
 		    /// The set function of the map
 		    void set(const Key& key, Value value) {
 		      if (value) {
 		        *_end++ = key;
+		      }
+		    }
 		  private:
 		    Iterator _begin;
 		    Iterator _end;
 		  };
 		  /// Returns a \c LoggerBoolMap class
 		  /// This function just returns a \c LoggerBoolMap class.
 		  ///
 		  /// The most important usage of it is storing certain nodes or arcs
 		  /// that were marked \c true by an algorithm.
 		  /// For example it makes easier to store the nodes in the processing
 		  /// order of Dfs algorithm, as the following examples show.
 		  /// \code
 		  ///   std::vector<Node> v;
 		  ///   dfs(g).processedMap(loggerBoolMap(std::back_inserter(v))).run(s);
 		  /// \endcode
 		  /// \code
 		  ///   std::vector<Node> v(countNodes(g));
 		  ///   dfs(g).processedMap(loggerBoolMap(v.begin())).run(s);
 		  /// \endcode
 		  ///
 		  /// \note The container of the iterator must contain enough space
 		  /// for the elements or the iterator should be an inserter iterator.
 		  ///
 		  /// \note LoggerBoolMap is just \ref concepts::WriteMap "writable", so
 		  /// it cannot be used when a readable map is needed, for example as
 		  /// \c ReachedMap for \c Bfs, \c Dfs and \c Dijkstra algorithms.
 		  ///
 		  /// \relates LoggerBoolMap
 		  template<typename Iterator>
 		  inline LoggerBoolMap<Iterator> loggerBoolMap(Iterator it) {
 		    return LoggerBoolMap<Iterator>(it);
+		  }
 		  /// @}
 		  /// \addtogroup graph_maps
 		  /// @{
 		  /// \brief Provides an immutable and unique id for each item in a graph.
 		  ///
 		  /// IdMap provides a unique and immutable id for each item of the
-		  /// same type (\c Node, \c Arc or \c Edge) in a graph. This id is
 		  /// same type (\c Node, \c Arc or \c Edge) in a graph. This id is
 		  ///  - \b unique: different items get different ids,
 		  ///  - \b immutable: the id of an item does not change (even if you
 		  ///    delete other nodes).
 		  ///
 		  /// Using this map you get access (i.e. can read) the inner id values of
 		  /// the items stored in the graph, which is returned by the \c id()
 		  /// function of the graph. This map can be inverted with its member
 		  /// class \c InverseMap or with the \c operator() member.
 		  ///
 		  /// \tparam GR The graph type.
 		  /// \tparam K The key type of the map (\c GR::Node, \c GR::Arc or
 		  /// \c GR::Edge).
 		  ///
 		  /// \see RangeIdMap
 		  template <typename GR, typename K>
 		  class IdMap : public MapBase<K, int> {
 		  public:
 		    /// The graph type of IdMap.
 		    typedef GR Graph;
 		    typedef GR Digraph;
 		    /// The key type of IdMap (\c Node, \c Arc or \c Edge).
 		    typedef K Item;
 		    /// The key type of IdMap (\c Node, \c Arc or \c Edge).
 		    typedef K Key;
 		    /// The value type of IdMap.
 		    typedef int Value;
 		    /// \brief Constructor.
 		    ///
 		    /// Constructor of the map.
 		    explicit IdMap(const Graph& graph) : _graph(&graph) {}
 		    /// \brief Gives back the \e id of the item.
 		    ///
 		    /// Gives back the immutable and unique \e id of the item.
 		    int operator[](const Item& item) const { return _graph->id(item);}
 		    /// \brief Gives back the \e item by its id.
 		    ///
 		    /// Gives back the \e item by its id.
 		    Item operator()(int id) { return _graph->fromId(id, Item()); }
 		  private:
 		    const Graph* _graph;
 		  public:
 		    /// \brief This class represents the inverse of its owner (IdMap).
 		    ///
 		    /// This class represents the inverse of its owner (IdMap).
 		    /// \see inverse()
 		    class InverseMap {
 		    public:
 		      /// \brief Constructor.
 		      ///
 		      /// Constructor for creating an id-to-item map.
 		      explicit InverseMap(const Graph& graph) : _graph(&graph) {}
 		      /// \brief Constructor.
 		      ///
 		      /// Constructor for creating an id-to-item map.
 		      explicit InverseMap(const IdMap& map) : _graph(map._graph) {}
 		      /// \brief Gives back the given item from its id.
 		      ///
 		      /// Gives back the given item from its id.
 		      Item operator[](int id) const { return _graph->fromId(id, Item());}
 		    private:
 		      const Graph* _graph;
 		    };
 		    /// \brief Gives back the inverse of the map.
 		    ///
 		    /// Gives back the inverse of the IdMap.
 		    InverseMap inverse() const { return InverseMap(*_graph);}
 		  };
 		  /// \brief General cross reference graph map type.
 		  /// This class provides simple invertable graph maps.
 		  /// It wraps an arbitrary \ref concepts::ReadWriteMap "ReadWriteMap"
 		  /// and if a key is set to a new value then store it
 		  /// in the inverse map.
 		  ///
 		  /// It wraps a standard graph map (\c NodeMap, \c ArcMap or \c EdgeMap)
 		  /// and if a key is set to a new value, then stores it in the inverse map.
 		  /// The values of the map can be accessed
 		  /// with stl compatible forward iterator.
 		  ///
 		  /// This type is not reference map, so it cannot be modified with
 		  /// the subscript operator.
 		  ///
 		  /// \tparam GR The graph type.
 		  /// \tparam K The key type of the map (\c GR::Node, \c GR::Arc or
 		  /// \c GR::Edge).
 		  /// \tparam V The value type of the map.
 		  ///
 		  /// \see IterableValueMap
 		  template <typename GR, typename K, typename V>
 		  class CrossRefMap
 		    : protected ItemSetTraits<GR, K>::template Map<V>::Type {
 		  private:
 		    typedef typename ItemSetTraits<GR, K>::
 		      template Map<V>::Type Map;
-		    typedef std::map<V, K> Container;
+		    typedef std::multimap<V, K> Container;
 		    Container _inv_map;
 		  public:
 		    /// The graph type of CrossRefMap.
 		    typedef GR Graph;
 		    typedef GR Digraph;
 		    /// The key type of CrossRefMap (\c Node, \c Arc or \c Edge).
 		    typedef K Item;
 		    /// The key type of CrossRefMap (\c Node, \c Arc or \c Edge).
 		    typedef K Key;
 		    /// The value type of CrossRefMap.
 		    typedef V Value;
 		    /// \brief Constructor.
 		    ///
 		    /// Construct a new CrossRefMap for the given graph.
 		    explicit CrossRefMap(const Graph& graph) : Map(graph) {}
 		    /// \brief Forward iterator for values.
 		    ///
 		    /// This iterator is an stl compatible forward
 		    /// iterator on the values of the map. The values can
 		    /// be accessed in the <tt>[beginValue, endValue)</tt> range.
 		    /// They are considered with multiplicity, so each value is
 		    /// traversed for each item it is assigned to.
 		    class ValueIterator
 		      : public std::iterator<std::forward_iterator_tag, Value> {
 		      friend class CrossRefMap;
 		    private:
 		      ValueIterator(typename Container::const_iterator _it)
 		        : it(_it) {}
 		    public:
 		      ValueIterator() {}
 		      ValueIterator& operator++() { ++it; return *this; }
 		      ValueIterator operator++(int) {
 		        ValueIterator tmp(*this);
 		        operator++();
 		        return tmp;
+		      }
 		      const Value& operator*() const { return it->first; }
 		      const Value* operator->() const { return &(it->first); }
 		      bool operator==(ValueIterator jt) const { return it == jt.it; }
 		      bool operator!=(ValueIterator jt) const { return it != jt.it; }
 		    private:
 		      typename Container::const_iterator it;
 		    };
 		    /// \brief Returns an iterator to the first value.
 		    ///
 		    /// Returns an stl compatible iterator to the
 		    /// first value of the map. The values of the
 		    /// map can be accessed in the <tt>[beginValue, endValue)</tt>
 		    /// range.
 		    ValueIterator beginValue() const {
 		      return ValueIterator(_inv_map.begin());
+		    }
 		    /// \brief Returns an iterator after the last value.
 		    ///
 		    /// Returns an stl compatible iterator after the
 		    /// last value of the map. The values of the
 		    /// map can be accessed in the <tt>[beginValue, endValue)</tt>
 		    /// range.
 		    ValueIterator endValue() const {
 		      return ValueIterator(_inv_map.end());
+		    }
 		    /// \brief Sets the value associated with the given key.
 		    ///
 		    /// Sets the value associated with the given key.
 		    void set(const Key& key, const Value& val) {
 		      Value oldval = Map::operator[](key);
 		      typename Container::iterator it = _inv_map.find(oldval);
 		      if (it != _inv_map.end() && it->second == key) {
-		        _inv_map.erase(it);
+		      typename Container::iterator it;
 		      for (it = _inv_map.equal_range(oldval).first;
 		           it != _inv_map.equal_range(oldval).second; ++it) {
 		        if (it->second == key) {
 		          _inv_map.erase(it);
 		          break;
+		        }
+		      }
 		      _inv_map.insert(make_pair(val, key));
+		      _inv_map.insert(std::make_pair(val, key));
 		      Map::set(key, val);
+		    }
 		    /// \brief Returns the value associated with the given key.
 		    ///
 		    /// Returns the value associated with the given key.
 		    typename MapTraits<Map>::ConstReturnValue
 		    operator[](const Key& key) const {
 		      return Map::operator[](key);
+		    }
-		    /// \brief Gives back the item by its value.
+		    /// \brief Gives back an item by its value.
 		    ///
 		    /// Gives back the item by its value.
 		    Key operator()(const Value& key) const {
-		      typename Container::const_iterator it = _inv_map.find(key);
+		    /// This function gives back an item that is assigned to
 		    /// the given value or \c INVALID if no such item exists.
 		    /// If there are more items with the same associated value,
 		    /// only one of them is returned.
 		    Key operator()(const Value& val) const {
 		      typename Container::const_iterator it = _inv_map.find(val);
 		      return it != _inv_map.end() ? it->second : INVALID;
+		    }
 		  protected:
 		    /// \brief Erase the key from the map and the inverse map.
 		    ///
 		    /// Erase the key from the map and the inverse map. It is called by the
 		    /// \c AlterationNotifier.
 		    virtual void erase(const Key& key) {
 		      Value val = Map::operator[](key);
 		      typename Container::iterator it = _inv_map.find(val);
 		      if (it != _inv_map.end() && it->second == key) {
-		        _inv_map.erase(it);
+		      typename Container::iterator it;
 		      for (it = _inv_map.equal_range(val).first;
 		           it != _inv_map.equal_range(val).second; ++it) {
 		        if (it->second == key) {
 		          _inv_map.erase(it);
 		          break;
+		        }
+		      }
 		      Map::erase(key);
+		    }
 		    /// \brief Erase more keys from the map and the inverse map.
 		    ///
 		    /// Erase more keys from the map and the inverse map. It is called by the
 		    /// \c AlterationNotifier.
 		    virtual void erase(const std::vector<Key>& keys) {
 		      for (int i = 0; i < int(keys.size()); ++i) {
 		        Value val = Map::operator[](keys[i]);
 		        typename Container::iterator it = _inv_map.find(val);
 		        if (it != _inv_map.end() && it->second == keys[i]) {
-		          _inv_map.erase(it);
+		        typename Container::iterator it;
 		        for (it = _inv_map.equal_range(val).first;
 		             it != _inv_map.equal_range(val).second; ++it) {
 		          if (it->second == keys[i]) {
 		            _inv_map.erase(it);
 		            break;
+		          }
+		        }
+		      }
 		      Map::erase(keys);
+		    }
 		    /// \brief Clear the keys from the map and the inverse map.
 		    ///
 		    /// Clear the keys from the map and the inverse map. It is called by the
 		    /// \c AlterationNotifier.
 		    virtual void clear() {
 		      _inv_map.clear();
 		      Map::clear();
+		    }
 		  public:
 		    /// \brief The inverse map type.
 		    ///
 		    /// The inverse of this map. The subscript operator of the map
 		    /// gives back the item that was last assigned to the value.
 		    class InverseMap {
 		    public:
 		      /// \brief Constructor
 		      ///
 		      /// Constructor of the InverseMap.
 		      explicit InverseMap(const CrossRefMap& inverted)
 		        : _inverted(inverted) {}
 		      /// The value type of the InverseMap.
 		      typedef typename CrossRefMap::Key Value;
 		      /// The key type of the InverseMap.
 		      typedef typename CrossRefMap::Value Key;
 		      /// \brief Subscript operator.
 		      ///
 		      /// Subscript operator. It gives back the item
 		      /// that was last assigned to the given value.
 		      /// Subscript operator. It gives back an item
 		      /// that is assigned to the given value or \c INVALID
 		      /// if no such item exists.
 		      Value operator[](const Key& key) const {
 		        return _inverted(key);
+		      }
 		    private:
 		      const CrossRefMap& _inverted;
 		    };
 		    /// \brief It gives back the read-only inverse map.
 		    ///
 		    /// It gives back the read-only inverse map.
 		    InverseMap inverse() const {
 		      return InverseMap(*this);
+		    }
 		  };
 		  /// \brief Provides continuous and unique ID for the
 		  /// items of a graph.
 		  ///
 		  /// RangeIdMap provides a unique and continuous
 		  /// ID for each item of a given type (\c Node, \c Arc or
 		  /// \c Edge) in a graph. This id is
 		  ///  - \b unique: different items get different ids,
 		  ///  - \b continuous: the range of the ids is the set of integers
 		  ///    between 0 and \c n-1, where \c n is the number of the items of
 		  ///    this type (\c Node, \c Arc or \c Edge).
 		  ///  - So, the ids can change when deleting an item of the same type.
 		  ///
 		  /// Thus this id is not (necessarily) the same as what can get using
 		  /// the \c id() function of the graph or \ref IdMap.
 		  /// This map can be inverted with its member class \c InverseMap,
 		  /// or with the \c operator() member.
 		  ///
 		  /// \tparam GR The graph type.
 		  /// \tparam K The key type of the map (\c GR::Node, \c GR::Arc or
 		  /// \c GR::Edge).
 		  ///
 		  /// \see IdMap
 		  template <typename GR, typename K>
 		  class RangeIdMap
 		    : protected ItemSetTraits<GR, K>::template Map<int>::Type {
 		    typedef typename ItemSetTraits<GR, K>::template Map<int>::Type Map;
 		  public:
 		    /// The graph type of RangeIdMap.
 		    typedef GR Graph;
 		    typedef GR Digraph;
 		    /// The key type of RangeIdMap (\c Node, \c Arc or \c Edge).
 		    typedef K Item;
 		    /// The key type of RangeIdMap (\c Node, \c Arc or \c Edge).
 		    typedef K Key;
 		    /// The value type of RangeIdMap.
 		    typedef int Value;
 		    /// \brief Constructor.
 		    ///
 		    /// Constructor.
 		    explicit RangeIdMap(const Graph& gr) : Map(gr) {
 		      Item it;
 		      const typename Map::Notifier* nf = Map::notifier();
 		      for (nf->first(it); it != INVALID; nf->next(it)) {
 		        Map::set(it, _inv_map.size());
 		        _inv_map.push_back(it);
+		      }
+		    }
 		  protected:
 		    /// \brief Adds a new key to the map.
 		    ///
 		    /// Add a new key to the map. It is called by the
 		    /// \c AlterationNotifier.
 		    virtual void add(const Item& item) {
 		      Map::add(item);
 		      Map::set(item, _inv_map.size());
 		      _inv_map.push_back(item);
+		    }
 		    /// \brief Add more new keys to the map.
 		    ///
 		    /// Add more new keys to the map. It is called by the
 		    /// \c AlterationNotifier.
 		    virtual void add(const std::vector<Item>& items) {
 		      Map::add(items);
 		      for (int i = 0; i < int(items.size()); ++i) {
 		        Map::set(items[i], _inv_map.size());
 		        _inv_map.push_back(items[i]);
+		      }
+		    }
 		    /// \brief Erase the key from the map.
 		    ///
 		    /// Erase the key from the map. It is called by the
 		    /// \c AlterationNotifier.
 		    virtual void erase(const Item& item) {
 		      Map::set(_inv_map.back(), Map::operator[](item));
 		      _inv_map[Map::operator[](item)] = _inv_map.back();
 		      _inv_map.pop_back();
 		      Map::erase(item);
+		    }
 		    /// \brief Erase more keys from the map.
 		    ///
 		    /// Erase more keys from the map. It is called by the
 		    /// \c AlterationNotifier.
 		    virtual void erase(const std::vector<Item>& items) {
 		      for (int i = 0; i < int(items.size()); ++i) {
 		        Map::set(_inv_map.back(), Map::operator[](items[i]));
 		        _inv_map[Map::operator[](items[i])] = _inv_map.back();
 		        _inv_map.pop_back();
+		      }
 		      Map::erase(items);
+		    }
 		    /// \brief Build the unique map.
 		    ///
 		    /// Build the unique map. It is called by the
 		    /// \c AlterationNotifier.
 		    virtual void build() {
 		      Map::build();
 		      Item it;
 		      const typename Map::Notifier* nf = Map::notifier();
 		      for (nf->first(it); it != INVALID; nf->next(it)) {
 		        Map::set(it, _inv_map.size());
 		        _inv_map.push_back(it);
+		      }
+		    }
 		    /// \brief Clear the keys from the map.
 		    ///
 		    /// Clear the keys from the map. It is called by the
 		    /// \c AlterationNotifier.
 		    virtual void clear() {
 		      _inv_map.clear();
 		      Map::clear();
+		    }
 		  public:
 		    /// \brief Returns the maximal value plus one.
 		    ///
 		    /// Returns the maximal value plus one in the map.
 		    unsigned int size() const {
 		      return _inv_map.size();
+		    }
 		    /// \brief Swaps the position of the two items in the map.
 		    ///
 		    /// Swaps the position of the two items in the map.
 		    void swap(const Item& p, const Item& q) {
 		      int pi = Map::operator[](p);
 		      int qi = Map::operator[](q);
 		      Map::set(p, qi);
 		      _inv_map[qi] = p;
 		      Map::set(q, pi);
 		      _inv_map[pi] = q;
+		    }
 		    /// \brief Gives back the \e RangeId of the item
 		    ///
 		    /// Gives back the \e RangeId of the item.
 		    int operator[](const Item& item) const {
 		      return Map::operator[](item);
+		    }
 		    /// \brief Gives back the item belonging to a \e RangeId
-		    ///
 		    ///
 		    /// Gives back the item belonging to a \e RangeId.
 		    Item operator()(int id) const {
 		      return _inv_map[id];
+		    }
 		  private:
 		    typedef std::vector<Item> Container;
 		    Container _inv_map;
 		  public:
 		    /// \brief The inverse map type of RangeIdMap.
 		    ///
 		    /// The inverse map type of RangeIdMap.
 		    class InverseMap {
 		    public:
 		      /// \brief Constructor
 		      ///
 		      /// Constructor of the InverseMap.
 		      explicit InverseMap(const RangeIdMap& inverted)
 		        : _inverted(inverted) {}
 		      /// The value type of the InverseMap.
 		      typedef typename RangeIdMap::Key Value;
 		      /// The key type of the InverseMap.
 		      typedef typename RangeIdMap::Value Key;
 		      /// \brief Subscript operator.
 		      ///
 		      /// Subscript operator. It gives back the item
 		      /// that the descriptor currently belongs to.
 		      Value operator[](const Key& key) const {
 		        return _inverted(key);
+		      }
 		      /// \brief Size of the map.
 		      ///
 		      /// Returns the size of the map.
 		      unsigned int size() const {
 		        return _inverted.size();
+		      }
 		    private:
 		      const RangeIdMap& _inverted;
 		    };
 		    /// \brief Gives back the inverse of the map.
 		    ///
 		    /// Gives back the inverse of the map.
 		    const InverseMap inverse() const {
 		      return InverseMap(*this);
+		    }
 		  };
 		  /// \brief Dynamic iterable \c bool map.
 		  ///
 		  /// This class provides a special graph map type which can store a
 		  /// \c bool value for graph items (\c Node, \c Arc or \c Edge).
 		  /// For both \c true and \c false values it is possible to iterate on
 		  /// the keys.
 		  ///
 		  /// This type is a reference map, so it can be modified with the
 		  /// subscript operator.
 		  ///
 		  /// \tparam GR The graph type.
 		  /// \tparam K The key type of the map (\c GR::Node, \c GR::Arc or
 		  /// \c GR::Edge).
 		  ///
 		  /// \see IterableIntMap, IterableValueMap
 		  /// \see CrossRefMap
 		  template <typename GR, typename K>
 		  class IterableBoolMap
 		    : protected ItemSetTraits<GR, K>::template Map<int>::Type {
 		  private:
 		    typedef GR Graph;
 		    typedef typename ItemSetTraits<GR, K>::ItemIt KeyIt;
 		    typedef typename ItemSetTraits<GR, K>::template Map<int>::Type Parent;
 		    std::vector<K> _array;
 		    int _sep;
 		  public:
 		    /// Indicates that the map is reference map.
 		    typedef True ReferenceMapTag;
 		    /// The key type
 		    typedef K Key;
 		    /// The value type
 		    typedef bool Value;
 		    /// The const reference type.
 		    typedef const Value& ConstReference;
 		  private:
 		    int position(const Key& key) const {
 		      return Parent::operator[](key);
+		    }
 		  public:
 		    /// \brief Reference to the value of the map.
 		    ///
 		    /// This class is similar to the \c bool type. It can be converted to
 		    /// \c bool and it provides the same operators.
 		    class Reference {
 		      friend class IterableBoolMap;
 		    private:
 		      Reference(IterableBoolMap& map, const Key& key)
 		        : _key(key), _map(map) {}
 		    public:
 		      Reference& operator=(const Reference& value) {
 		        _map.set(_key, static_cast<bool>(value));
 		         return *this;
+		      }
 		      operator bool() const {
 		        return static_cast<const IterableBoolMap&>(_map)[_key];
+		      }
 		      Reference& operator=(bool value) {
 		        _map.set(_key, value);
 		        return *this;
+		      }
 		      Reference& operator&=(bool value) {
 		        _map.set(_key, _map[_key] & value);
 		        return *this;
+		      }
 		      Reference& operator|=(bool value) {
 		        _map.set(_key, _map[_key] | value);
 		        return *this;
+		      }
 		      Reference& operator^=(bool value) {
 		        _map.set(_key, _map[_key] ^ value);
 		        return *this;
+		      }
 		    private:
 		      Key _key;
 		      IterableBoolMap& _map;
 		    };
 		    /// \brief Constructor of the map with a default value.
 		    ///
 		    /// Constructor of the map with a default value.
 		    explicit IterableBoolMap(const Graph& graph, bool def = false)
 		      : Parent(graph) {
 		      typename Parent::Notifier* nf = Parent::notifier();
 		      Key it;
 		      for (nf->first(it); it != INVALID; nf->next(it)) {
 		        Parent::set(it, _array.size());
 		        _array.push_back(it);
+		      }
 		      _sep = (def ? _array.size() : 0);
+		    }
 		    /// \brief Const subscript operator of the map.
 		    ///
 		    /// Const subscript operator of the map.
 		    bool operator[](const Key& key) const {
 		      return position(key) < _sep;
+		    }
 		    /// \brief Subscript operator of the map.
 		    ///
 		    /// Subscript operator of the map.
 		    Reference operator[](const Key& key) {
 		      return Reference(*this, key);
+		    }
 		    /// \brief Set operation of the map.
 		    ///
 		    /// Set operation of the map.
 		    void set(const Key& key, bool value) {
 		      int pos = position(key);
 		      if (value) {
 		        if (pos < _sep) return;
 		        Key tmp = _array[_sep];
 		        _array[_sep] = key;
 		        Parent::set(key, _sep);
 		        _array[pos] = tmp;
 		        Parent::set(tmp, pos);
 		        ++_sep;
 		      } else {
 		        if (pos >= _sep) return;
 		        --_sep;
 		        Key tmp = _array[_sep];
 		        _array[_sep] = key;
 		        Parent::set(key, _sep);
 		        _array[pos] = tmp;
 		        Parent::set(tmp, pos);
+		      }
+		    }
 		    /// \brief Set all items.
 		    ///
 		    /// Set all items in the map.
 		    /// \note Constant time operation.
 		    void setAll(bool value) {
 		      _sep = (value ? _array.size() : 0);
+		    }
 		    /// \brief Returns the number of the keys mapped to \c true.
 		    ///
 		    /// Returns the number of the keys mapped to \c true.
 		    int trueNum() const {
 		      return _sep;
+		    }
 		    /// \brief Returns the number of the keys mapped to \c false.
 		    ///
 		    /// Returns the number of the keys mapped to \c false.
 		    int falseNum() const {
 		      return _array.size() - _sep;
+		    }
 		    /// \brief Iterator for the keys mapped to \c true.
 		    ///
 		    /// Iterator for the keys mapped to \c true. It works
 		    /// like a graph item iterator, it can be converted to
 		    /// the key type of the map, incremented with \c ++ operator, and
 		    /// if the iterator leaves the last valid key, it will be equal to
 		    /// \c INVALID.
 		    class TrueIt : public Key {
 		    public:
 		      typedef Key Parent;
 		      /// \brief Creates an iterator.
 		      ///
 		      /// Creates an iterator. It iterates on the
 		      /// keys mapped to \c true.
 		      /// \param map The IterableBoolMap.
 		      explicit TrueIt(const IterableBoolMap& map)
 		        : Parent(map._sep > 0 ? map._array[map._sep - 1] : INVALID),
 		          _map(&map) {}
 		      /// \brief Invalid constructor \& conversion.
 		      ///
 		      /// This constructor initializes the iterator to be invalid.
 		      /// \sa Invalid for more details.
 		      TrueIt(Invalid) : Parent(INVALID), _map(0) {}
 		      /// \brief Increment operator.
 		      ///
 		      /// Increment operator.
 		      TrueIt& operator++() {
 		        int pos = _map->position(*this);
 		        Parent::operator=(pos > 0 ? _map->_array[pos - 1] : INVALID);
 		        return *this;
+		      }
 		    private:
 		      const IterableBoolMap* _map;
 		    };
 		    /// \brief Iterator for the keys mapped to \c false.
 		    ///
 		    /// Iterator for the keys mapped to \c false. It works
 		    /// like a graph item iterator, it can be converted to
 		    /// the key type of the map, incremented with \c ++ operator, and
 		    /// if the iterator leaves the last valid key, it will be equal to
 		    /// \c INVALID.
 		    class FalseIt : public Key {
 		    public:
 		      typedef Key Parent;
 		      /// \brief Creates an iterator.
 		      ///
 		      /// Creates an iterator. It iterates on the
 		      /// keys mapped to \c false.
 		      /// \param map The IterableBoolMap.
 		      explicit FalseIt(const IterableBoolMap& map)
 		        : Parent(map._sep < int(map._array.size()) ?
 		                 map._array.back() : INVALID), _map(&map) {}
 		      /// \brief Invalid constructor \& conversion.
 		      ///
 		      /// This constructor initializes the iterator to be invalid.
 		      /// \sa Invalid for more details.
 		      FalseIt(Invalid) : Parent(INVALID), _map(0) {}
 		      /// \brief Increment operator.
 		      ///
 		      /// Increment operator.
 		      FalseIt& operator++() {
 		        int pos = _map->position(*this);
 		        Parent::operator=(pos > _map->_sep ? _map->_array[pos - 1] : INVALID);
 		        return *this;
+		      }
 		    private:
 		      const IterableBoolMap* _map;
 		    };
 		    /// \brief Iterator for the keys mapped to a given value.
 		    ///
 		    /// Iterator for the keys mapped to a given value. It works
 		    /// like a graph item iterator, it can be converted to
 		    /// the key type of the map, incremented with \c ++ operator, and
 		    /// if the iterator leaves the last valid key, it will be equal to
 		    /// \c INVALID.
 		    class ItemIt : public Key {
 		    public:
 		      typedef Key Parent;
 		      /// \brief Creates an iterator with a value.
 		      ///
 		      /// Creates an iterator with a value. It iterates on the
 		      /// keys mapped to the given value.
 		      /// \param map The IterableBoolMap.
 		      /// \param value The value.
 		      ItemIt(const IterableBoolMap& map, bool value)
 		        : Parent(value ?
 		                 (map._sep > 0 ?
 		                  map._array[map._sep - 1] : INVALID) :
 		                 (map._sep < int(map._array.size()) ?
 		                  map._array.back() : INVALID)), _map(&map) {}
 		      /// \brief Invalid constructor \& conversion.
 		      ///
 		      /// This constructor initializes the iterator to be invalid.
 		      /// \sa Invalid for more details.
 		      ItemIt(Invalid) : Parent(INVALID), _map(0) {}
 		      /// \brief Increment operator.
 		      ///
 		      /// Increment operator.
 		      ItemIt& operator++() {
 		        int pos = _map->position(*this);
 		        int _sep = pos >= _map->_sep ? _map->_sep : 0;
 		        Parent::operator=(pos > _sep ? _map->_array[pos - 1] : INVALID);
 		        return *this;
+		      }
 		    private:
 		      const IterableBoolMap* _map;
 		    };
 		  protected:
 		    virtual void add(const Key& key) {
 		      Parent::add(key);
 		      Parent::set(key, _array.size());
 		      _array.push_back(key);
+		    }
 		    virtual void add(const std::vector<Key>& keys) {
 		      Parent::add(keys);
 		      for (int i = 0; i < int(keys.size()); ++i) {
 		        Parent::set(keys[i], _array.size());
 		        _array.push_back(keys[i]);
+		      }
+		    }
 		    virtual void erase(const Key& key) {
 		      int pos = position(key);
 		      if (pos < _sep) {
 		        --_sep;
 		        Parent::set(_array[_sep], pos);
 		        _array[pos] = _array[_sep];
 		        Parent::set(_array.back(), _sep);
 		        _array[_sep] = _array.back();
 		        _array.pop_back();
 		      } else {
 		        Parent::set(_array.back(), pos);
 		        _array[pos] = _array.back();
 		        _array.pop_back();
+		      }
 		      Parent::erase(key);
+		    }
 		    virtual void erase(const std::vector<Key>& keys) {
 		      for (int i = 0; i < int(keys.size()); ++i) {
 		        int pos = position(keys[i]);
 		        if (pos < _sep) {
 		          --_sep;
 		          Parent::set(_array[_sep], pos);
 		          _array[pos] = _array[_sep];
 		          Parent::set(_array.back(), _sep);
 		          _array[_sep] = _array.back();
 		          _array.pop_back();
 		        } else {
 		          Parent::set(_array.back(), pos);
 		          _array[pos] = _array.back();
 		          _array.pop_back();
+		        }
+		      }
 		      Parent::erase(keys);
+		    }
 		    virtual void build() {
 		      Parent::build();
 		      typename Parent::Notifier* nf = Parent::notifier();
 		      Key it;
 		      for (nf->first(it); it != INVALID; nf->next(it)) {
 		        Parent::set(it, _array.size());
 		        _array.push_back(it);
+		      }
 		      _sep = 0;
+		    }
 		    virtual void clear() {
 		      _array.clear();
 		      _sep = 0;
 		      Parent::clear();
+		    }
 		  };
 		  namespace _maps_bits {
 		    template <typename Item>
 		    struct IterableIntMapNode {
 		      IterableIntMapNode() : value(-1) {}
 		      IterableIntMapNode(int _value) : value(_value) {}
 		      Item prev, next;
 		      int value;
 		    };
+		  }
 		  /// \brief Dynamic iterable integer map.
 		  ///
 		  /// This class provides a special graph map type which can store an
 		  /// integer value for graph items (\c Node, \c Arc or \c Edge).
 		  /// For each non-negative value it is possible to iterate on the keys
 		  /// mapped to the value.
 		  ///
 		  /// This type is a reference map, so it can be modified with the
 		  /// subscript operator.
 		  ///
 		  /// \note The size of the data structure depends on the largest
 		  /// value in the map.
 		  ///
 		  /// \tparam GR The graph type.
 		  /// \tparam K The key type of the map (\c GR::Node, \c GR::Arc or
 		  /// \c GR::Edge).
 		  ///
 		  /// \see IterableBoolMap, IterableValueMap
 		  /// \see CrossRefMap
 		  template <typename GR, typename K>
 		  class IterableIntMap
 		    : protected ItemSetTraits<GR, K>::
 		        template Map<_maps_bits::IterableIntMapNode<K> >::Type {
 		  public:
 		    typedef typename ItemSetTraits<GR, K>::
 		      template Map<_maps_bits::IterableIntMapNode<K> >::Type Parent;
 		    /// The key type
 		    typedef K Key;
 		    /// The value type
 		    typedef int Value;
 		    /// The graph type
 		    typedef GR Graph;
 		    /// \brief Constructor of the map.
 		    ///
 		    /// Constructor of the map. It sets all values to -1.
 		    explicit IterableIntMap(const Graph& graph)
 		      : Parent(graph) {}
 		    /// \brief Constructor of the map with a given value.
 		    ///
 		    /// Constructor of the map with a given value.
 		    explicit IterableIntMap(const Graph& graph, int value)
 		      : Parent(graph, _maps_bits::IterableIntMapNode<K>(value)) {
 		      if (value >= 0) {
 		        for (typename Parent::ItemIt it(*this); it != INVALID; ++it) {
 		          lace(it);
+		        }
+		      }
+		    }
 		  private:
 		    void unlace(const Key& key) {
 		      typename Parent::Value& node = Parent::operator[](key);
 		      if (node.value < 0) return;
 		      if (node.prev != INVALID) {
 		        Parent::operator[](node.prev).next = node.next;
 		      } else {
 		        _first[node.value] = node.next;
+		      }
 		      if (node.next != INVALID) {
 		        Parent::operator[](node.next).prev = node.prev;
+		      }
 		      while (!_first.empty() && _first.back() == INVALID) {
 		        _first.pop_back();
+		      }
+		    }
 		    void lace(const Key& key) {
 		      typename Parent::Value& node = Parent::operator[](key);
 		      if (node.value < 0) return;
 		      if (node.value >= int(_first.size())) {
 		        _first.resize(node.value + 1, INVALID);
+		      }
 		      node.prev = INVALID;
 		      node.next = _first[node.value];
 		      if (node.next != INVALID) {
 		        Parent::operator[](node.next).prev = key;
+		      }
 		      _first[node.value] = key;
+		    }
 		  public:
 		    /// Indicates that the map is reference map.
 		    typedef True ReferenceMapTag;
 		    /// \brief Reference to the value of the map.
 		    ///
 		    /// This class is similar to the \c int type. It can
 		    /// be converted to \c int and it has the same operators.
 		    class Reference {
 		      friend class IterableIntMap;
 		    private:
 		      Reference(IterableIntMap& map, const Key& key)
 		        : _key(key), _map(map) {}
 		    public:
 		      Reference& operator=(const Reference& value) {
 		        _map.set(_key, static_cast<const int&>(value));
 		         return *this;
+		      }
 		      operator const int&() const {
 		        return static_cast<const IterableIntMap&>(_map)[_key];
+		      }
 		      Reference& operator=(int value) {
 		        _map.set(_key, value);
 		        return *this;
+		      }
 		      Reference& operator++() {
 		        _map.set(_key, _map[_key] + 1);
 		        return *this;
+		      }
 		      int operator++(int) {
 		        int value = _map[_key];
 		        _map.set(_key, value + 1);
 		        return value;
+		      }
 		      Reference& operator--() {
 		        _map.set(_key, _map[_key] - 1);
 		        return *this;
+		      }
 		      int operator--(int) {
 		        int value = _map[_key];
 		        _map.set(_key, value - 1);
 		        return value;
+		      }
 		      Reference& operator+=(int value) {
 		        _map.set(_key, _map[_key] + value);
 		        return *this;
+		      }
 		      Reference& operator-=(int value) {
 		        _map.set(_key, _map[_key] - value);
 		        return *this;
+		      }
 		      Reference& operator*=(int value) {
 		        _map.set(_key, _map[_key] * value);
 		        return *this;
+		      }
 		      Reference& operator/=(int value) {
 		        _map.set(_key, _map[_key] / value);
 		        return *this;
+		      }
 		      Reference& operator%=(int value) {
 		        _map.set(_key, _map[_key] % value);
 		        return *this;
+		      }
 		      Reference& operator&=(int value) {
 		        _map.set(_key, _map[_key] & value);
 		        return *this;
+		      }
 		      Reference& operator|=(int value) {
 		        _map.set(_key, _map[_key] | value);
 		        return *this;
+		      }
 		      Reference& operator^=(int value) {
 		        _map.set(_key, _map[_key] ^ value);
 		        return *this;
+		      }
 		      Reference& operator<<=(int value) {
 		        _map.set(_key, _map[_key] << value);
 		        return *this;
+		      }
 		      Reference& operator>>=(int value) {
 		        _map.set(_key, _map[_key] >> value);
 		        return *this;
+		      }
 		    private:
 		      Key _key;
 		      IterableIntMap& _map;
 		    };
 		    /// The const reference type.
 		    typedef const Value& ConstReference;
 		    /// \brief Gives back the maximal value plus one.
 		    ///
 		    /// Gives back the maximal value plus one.
 		    int size() const {
 		      return _first.size();
+		    }
 		    /// \brief Set operation of the map.
 		    ///
 		    /// Set operation of the map.
 		    void set(const Key& key, const Value& value) {
 		      unlace(key);
 		      Parent::operator[](key).value = value;
 		      lace(key);
+		    }
 		    /// \brief Const subscript operator of the map.
 		    ///
 		    /// Const subscript operator of the map.
 		    const Value& operator[](const Key& key) const {
 		      return Parent::operator[](key).value;
+		    }
 		    /// \brief Subscript operator of the map.
 		    ///
 		    /// Subscript operator of the map.
 		    Reference operator[](const Key& key) {
 		      return Reference(*this, key);
+		    }
 		    /// \brief Iterator for the keys with the same value.
 		    ///
 		    /// Iterator for the keys with the same value. It works
 		    /// like a graph item iterator, it can be converted to
 		    /// the item type of the map, incremented with \c ++ operator, and
 		    /// if the iterator leaves the last valid item, it will be equal to
 		    /// \c INVALID.
 		    class ItemIt : public Key {
 		    public:
 		      typedef Key Parent;
 		      /// \brief Invalid constructor \& conversion.
 		      ///
 		      /// This constructor initializes the iterator to be invalid.
 		      /// \sa Invalid for more details.
 		      ItemIt(Invalid) : Parent(INVALID), _map(0) {}
 		      /// \brief Creates an iterator with a value.
 		      ///
 		      /// Creates an iterator with a value. It iterates on the
 		      /// keys mapped to the given value.
 		      /// \param map The IterableIntMap.
 		      /// \param value The value.
 		      ItemIt(const IterableIntMap& map, int value) : _map(&map) {
 		        if (value < 0 || value >= int(_map->_first.size())) {
 		          Parent::operator=(INVALID);
 		        } else {
 		          Parent::operator=(_map->_first[value]);
+		        }
+		      }
 		      /// \brief Increment operator.
 		      ///
 		      /// Increment operator.
 		      ItemIt& operator++() {
 		        Parent::operator=(_map->IterableIntMap::Parent::
 		                          operator[](static_cast<Parent&>(*this)).next);
 		        return *this;
+		      }
 		    private:
 		      const IterableIntMap* _map;
 		    };
 		  protected:
 		    virtual void erase(const Key& key) {
 		      unlace(key);
 		      Parent::erase(key);
+		    }
 		    virtual void erase(const std::vector<Key>& keys) {
 		      for (int i = 0; i < int(keys.size()); ++i) {
 		        unlace(keys[i]);
+		      }
 		      Parent::erase(keys);
+		    }
 		    virtual void clear() {
 		      _first.clear();
 		      Parent::clear();
+		    }
 		  private:
 		    std::vector<Key> _first;
 		  };
 		  namespace _maps_bits {
 		    template <typename Item, typename Value>
 		    struct IterableValueMapNode {
 		      IterableValueMapNode(Value _value = Value()) : value(_value) {}
 		      Item prev, next;
 		      Value value;
 		    };
+		  }
 		  /// \brief Dynamic iterable map for comparable values.
 		  ///
 		  /// This class provides a special graph map type which can store an
 		  /// comparable value for graph items (\c Node, \c Arc or \c Edge).
 		  /// For each value it is possible to iterate on the keys mapped to
 		  /// the value.
 		  ///
 		  /// The map stores for each value a linked list with
 		  /// the items which mapped to the value, and the values are stored
 		  /// in balanced binary tree. The values of the map can be accessed
 		  /// with stl compatible forward iterator.
 		  ///
 		  /// This type is not reference map, so it cannot be modified with
 		  /// the subscript operator.
 		  ///
 		  /// \tparam GR The graph type.
 		  /// \tparam K The key type of the map (\c GR::Node, \c GR::Arc or
 		  /// \c GR::Edge).
 		  /// \tparam V The value type of the map. It can be any comparable
 		  /// value type.
 		  ///
 		  /// \see IterableBoolMap, IterableIntMap
 		  /// \see CrossRefMap
 		  template <typename GR, typename K, typename V>
 		  class IterableValueMap
 		    : protected ItemSetTraits<GR, K>::
 		        template Map<_maps_bits::IterableValueMapNode<K, V> >::Type {
 		  public:
 		    typedef typename ItemSetTraits<GR, K>::
 		      template Map<_maps_bits::IterableValueMapNode<K, V> >::Type Parent;
 		    /// The key type
 		    typedef K Key;
 		    /// The value type
 		    typedef V Value;
 		    /// The graph type
 		    typedef GR Graph;
 		  public:
 		    /// \brief Constructor of the map with a given value.
 		    ///
 		    /// Constructor of the map with a given value.
 		    explicit IterableValueMap(const Graph& graph,
 		                              const Value& value = Value())
 		      : Parent(graph, _maps_bits::IterableValueMapNode<K, V>(value)) {
 		      for (typename Parent::ItemIt it(*this); it != INVALID; ++it) {
 		        lace(it);
+		      }
+		    }
 		  protected:
 		    void unlace(const Key& key) {
 		      typename Parent::Value& node = Parent::operator[](key);
 		      if (node.prev != INVALID) {
 		        Parent::operator[](node.prev).next = node.next;
 		      } else {
 		        if (node.next != INVALID) {
 		          _first[node.value] = node.next;
 		        } else {
 		          _first.erase(node.value);
+		        }
+		      }
 		      if (node.next != INVALID) {
 		        Parent::operator[](node.next).prev = node.prev;
+		      }
+		    }
 		    void lace(const Key& key) {
 		      typename Parent::Value& node = Parent::operator[](key);
 		      typename std::map<Value, Key>::iterator it = _first.find(node.value);
 		      if (it == _first.end()) {
 		        node.prev = node.next = INVALID;
 		        _first.insert(std::make_pair(node.value, key));
 		      } else {
 		        node.prev = INVALID;
 		        node.next = it->second;
 		        if (node.next != INVALID) {
 		          Parent::operator[](node.next).prev = key;
+		        }
 		        it->second = key;
+		      }
+		    }
 		  public:
 		    /// \brief Forward iterator for values.
 		    ///
 		    /// This iterator is an stl compatible forward
 		    /// iterator on the values of the map. The values can
 		    /// be accessed in the <tt>[beginValue, endValue)</tt> range.
 		    class ValueIterator
 		      : public std::iterator<std::forward_iterator_tag, Value> {
 		      friend class IterableValueMap;
 		    private:
 		      ValueIterator(typename std::map<Value, Key>::const_iterator _it)
 		        : it(_it) {}
 		    public:
 		      ValueIterator() {}
 		      ValueIterator& operator++() { ++it; return *this; }
 		      ValueIterator operator++(int) {
 		        ValueIterator tmp(*this);
 		        operator++();
 		        return tmp;
+		      }
 		      const Value& operator*() const { return it->first; }
 		      const Value* operator->() const { return &(it->first); }
 		      bool operator==(ValueIterator jt) const { return it == jt.it; }
 		      bool operator!=(ValueIterator jt) const { return it != jt.it; }
 		    private:
 		      typename std::map<Value, Key>::const_iterator it;
 		    };
 		    /// \brief Returns an iterator to the first value.
 		    ///
 		    /// Returns an stl compatible iterator to the
 		    /// first value of the map. The values of the
 		    /// map can be accessed in the <tt>[beginValue, endValue)</tt>
 		    /// range.
 		    ValueIterator beginValue() const {
 		      return ValueIterator(_first.begin());
+		    }
 		    /// \brief Returns an iterator after the last value.
 		    ///
 		    /// Returns an stl compatible iterator after the
 		    /// last value of the map. The values of the
 		    /// map can be accessed in the <tt>[beginValue, endValue)</tt>
 		    /// range.
 		    ValueIterator endValue() const {
 		      return ValueIterator(_first.end());
+		    }
 		    /// \brief Set operation of the map.
 		    ///
 		    /// Set operation of the map.
 		    void set(const Key& key, const Value& value) {
 		      unlace(key);
 		      Parent::operator[](key).value = value;
 		      lace(key);
+		    }
 		    /// \brief Const subscript operator of the map.
 		    ///
 		    /// Const subscript operator of the map.
 		    const Value& operator[](const Key& key) const {
 		      return Parent::operator[](key).value;
+		    }
 		    /// \brief Iterator for the keys with the same value.
 		    ///
 		    /// Iterator for the keys with the same value. It works
 		    /// like a graph item iterator, it can be converted to
 		    /// the item type of the map, incremented with \c ++ operator, and
 		    /// if the iterator leaves the last valid item, it will be equal to
 		    /// \c INVALID.
 		    class ItemIt : public Key {
 		    public:
 		      typedef Key Parent;
 		      /// \brief Invalid constructor \& conversion.
 		      ///
 		      /// This constructor initializes the iterator to be invalid.
 		      /// \sa Invalid for more details.
 		      ItemIt(Invalid) : Parent(INVALID), _map(0) {}
 		      /// \brief Creates an iterator with a value.
 		      ///
 		      /// Creates an iterator with a value. It iterates on the
 		      /// keys which have the given value.
 		      /// \param map The IterableValueMap
 		      /// \param value The value
 		      ItemIt(const IterableValueMap& map, const Value& value) : _map(&map) {
 		        typename std::map<Value, Key>::const_iterator it =
 		          map._first.find(value);
 		        if (it == map._first.end()) {
 		          Parent::operator=(INVALID);
 		        } else {
 		          Parent::operator=(it->second);
+		        }
+		      }
 		      /// \brief Increment operator.
 		      ///
 		      /// Increment Operator.
 		      ItemIt& operator++() {
 		        Parent::operator=(_map->IterableValueMap::Parent::
 		                          operator[](static_cast<Parent&>(*this)).next);
 		        return *this;
+		      }
 		    private:
 		      const IterableValueMap* _map;
 		    };
 		  protected:
 		    virtual void add(const Key& key) {
 		      Parent::add(key);
 		      unlace(key);
+		    }
 		    virtual void add(const std::vector<Key>& keys) {
 		      Parent::add(keys);
 		      for (int i = 0; i < int(keys.size()); ++i) {
 		        lace(keys[i]);
+		      }
+		    }
 		    virtual void erase(const Key& key) {
 		      unlace(key);
 		      Parent::erase(key);
+		    }
 		    virtual void erase(const std::vector<Key>& keys) {
 		      for (int i = 0; i < int(keys.size()); ++i) {
 		        unlace(keys[i]);
+		      }
 		      Parent::erase(keys);
+		    }
 		    virtual void build() {
 		      Parent::build();
 		      for (typename Parent::ItemIt it(*this); it != INVALID; ++it) {
 		        lace(it);
+		      }
+		    }
 		    virtual void clear() {
 		      _first.clear();
 		      Parent::clear();
+		    }
 		  private:
 		    std::map<Value, Key> _first;
 		  };
 		  /// \brief Map of the source nodes of arcs in a digraph.
 		  ///
 		  /// SourceMap provides access for the source node of each arc in a digraph,
 		  /// which is returned by the \c source() function of the digraph.
 		  /// \tparam GR The digraph type.
 		  /// \see TargetMap
 		  template <typename GR>
 		  class SourceMap {
 		  public:
 		    ///\e
 		    typedef typename GR::Arc Key;
 		    ///\e
 		    typedef typename GR::Node Value;
 		    /// \brief Constructor
 		    ///
 		    /// Constructor.
 		    /// \param digraph The digraph that the map belongs to.
 		    explicit SourceMap(const GR& digraph) : _graph(digraph) {}
 		    /// \brief Returns the source node of the given arc.
 		    ///
 		    /// Returns the source node of the given arc.
 		    Value operator[](const Key& arc) const {
 		      return _graph.source(arc);
+		    }
 		  private:
 		    const GR& _graph;
 		  };
 		  /// \brief Returns a \c SourceMap class.
 		  ///
 		  /// This function just returns an \c SourceMap class.
 		  /// \relates SourceMap
 		  template <typename GR>
 		  inline SourceMap<GR> sourceMap(const GR& graph) {
 		    return SourceMap<GR>(graph);
+		  }
 		  /// \brief Map of the target nodes of arcs in a digraph.
 		  ///
 		  /// TargetMap provides access for the target node of each arc in a digraph,
 		  /// which is returned by the \c target() function of the digraph.
 		  /// \tparam GR The digraph type.
 		  /// \see SourceMap
 		  template <typename GR>
 		  class TargetMap {
 		  public:
 		    ///\e
 		    typedef typename GR::Arc Key;
 		    ///\e
 		    typedef typename GR::Node Value;
 		    /// \brief Constructor
 		    ///
 		    /// Constructor.
 		    /// \param digraph The digraph that the map belongs to.
 		    explicit TargetMap(const GR& digraph) : _graph(digraph) {}
 		    /// \brief Returns the target node of the given arc.
 		    ///
 		    /// Returns the target node of the given arc.
 		    Value operator[](const Key& e) const {
 		      return _graph.target(e);
+		    }
 		  private:
 		    const GR& _graph;
 		  };
 		  /// \brief Returns a \c TargetMap class.
 		  ///
 		  /// This function just returns a \c TargetMap class.
 		  /// \relates TargetMap
 		  template <typename GR>
 		  inline TargetMap<GR> targetMap(const GR& graph) {
 		    return TargetMap<GR>(graph);
+		  }
 		  /// \brief Map of the "forward" directed arc view of edges in a graph.
 		  ///
 		  /// ForwardMap provides access for the "forward" directed arc view of
 		  /// each edge in a graph, which is returned by the \c direct() function
 		  /// of the graph with \c true parameter.
 		  /// \tparam GR The graph type.
 		  /// \see BackwardMap
 		  template <typename GR>
 		  class ForwardMap {
 		  public:
 		    typedef typename GR::Arc Value;
 		    typedef typename GR::Edge Key;
 		    /// \brief Constructor
 		    ///
 		    /// Constructor.
 		    /// \param graph The graph that the map belongs to.
 		    explicit ForwardMap(const GR& graph) : _graph(graph) {}
 		    /// \brief Returns the "forward" directed arc view of the given edge.
 		    ///
 		    /// Returns the "forward" directed arc view of the given edge.
 		    Value operator[](const Key& key) const {
 		      return _graph.direct(key, true);
+		    }
 		  private:
 		    const GR& _graph;
 		  };
 		  /// \brief Returns a \c ForwardMap class.
 		  ///
 		  /// This function just returns an \c ForwardMap class.
 		  /// \relates ForwardMap
 		  template <typename GR>
 		  inline ForwardMap<GR> forwardMap(const GR& graph) {
 		    return ForwardMap<GR>(graph);
+		  }
 		  /// \brief Map of the "backward" directed arc view of edges in a graph.
 		  ///
 		  /// BackwardMap provides access for the "backward" directed arc view of
 		  /// each edge in a graph, which is returned by the \c direct() function
 		  /// of the graph with \c false parameter.
 		  /// \tparam GR The graph type.
 		  /// \see ForwardMap
 		  template <typename GR>
 		  class BackwardMap {
 		  public:
 		    typedef typename GR::Arc Value;
 		    typedef typename GR::Edge Key;
 		    /// \brief Constructor
 		    ///
 		    /// Constructor.
 		    /// \param graph The graph that the map belongs to.
 		    explicit BackwardMap(const GR& graph) : _graph(graph) {}
 		    /// \brief Returns the "backward" directed arc view of the given edge.
 		    ///
 		    /// Returns the "backward" directed arc view of the given edge.
 		    Value operator[](const Key& key) const {
 		      return _graph.direct(key, false);
+		    }
 		  private:
 		    const GR& _graph;
 		  };
 		  /// \brief Returns a \c BackwardMap class
 		  /// This function just returns a \c BackwardMap class.
 		  /// \relates BackwardMap
 		  template <typename GR>
 		  inline BackwardMap<GR> backwardMap(const GR& graph) {
 		    return BackwardMap<GR>(graph);
+		  }
 		  /// \brief Map of the in-degrees of nodes in a digraph.
 		  ///
 		  /// This map returns the in-degree of a node. Once it is constructed,
 		  /// the degrees are stored in a standard \c NodeMap, so each query is done
 		  /// in constant time. On the other hand, the values are updated automatically
 		  /// whenever the digraph changes.
 		  ///
-		  /// \warning Besides \c addNode() and \c addArc(), a digraph structure
 		  /// \warning Besides \c addNode() and \c addArc(), a digraph structure
 		  /// may provide alternative ways to modify the digraph.
 		  /// The correct behavior of InDegMap is not guarantied if these additional
 		  /// features are used. For example the functions
 		  /// \ref ListDigraph::changeSource() "changeSource()",
 		  /// \ref ListDigraph::changeTarget() "changeTarget()" and
 		  /// \ref ListDigraph::reverseArc() "reverseArc()"
 		  /// of \ref ListDigraph will \e not update the degree values correctly.
 		  ///
 		  /// \sa OutDegMap
 		  template <typename GR>
 		  class InDegMap
 		    : protected ItemSetTraits<GR, typename GR::Arc>
 		      ::ItemNotifier::ObserverBase {
 		  public:
 		    /// The graph type of InDegMap
 		    typedef GR Graph;
 		    typedef GR Digraph;
 		    /// The key type
 		    typedef typename Digraph::Node Key;
 		    /// The value type
 		    typedef int Value;
 		    typedef typename ItemSetTraits<Digraph, typename Digraph::Arc>
 		    ::ItemNotifier::ObserverBase Parent;
 		  private:
 		    class AutoNodeMap
 		      : public ItemSetTraits<Digraph, Key>::template Map<int>::Type {
 		    public:
 		      typedef typename ItemSetTraits<Digraph, Key>::
 		      template Map<int>::Type Parent;
 		      AutoNodeMap(const Digraph& digraph) : Parent(digraph, 0) {}
 		      virtual void add(const Key& key) {
 		        Parent::add(key);
 		        Parent::set(key, 0);
+		      }
 		      virtual void add(const std::vector<Key>& keys) {
 		        Parent::add(keys);
 		        for (int i = 0; i < int(keys.size()); ++i) {
 		          Parent::set(keys[i], 0);
+		        }
+		      }
 		      virtual void build() {
 		        Parent::build();
 		        Key it;
 		        typename Parent::Notifier* nf = Parent::notifier();
 		        for (nf->first(it); it != INVALID; nf->next(it)) {
 		          Parent::set(it, 0);
+		        }
+		      }
 		    };
 		  public:
 		    /// \brief Constructor.
 		    ///
 		    /// Constructor for creating an in-degree map.
 		    explicit InDegMap(const Digraph& graph)
 		      : _digraph(graph), _deg(graph) {
 		      Parent::attach(_digraph.notifier(typename Digraph::Arc()));
 		      for(typename Digraph::NodeIt it(_digraph); it != INVALID; ++it) {
 		        _deg[it] = countInArcs(_digraph, it);
+		      }
+		    }
 		    /// \brief Gives back the in-degree of a Node.
 		    ///
 		    /// Gives back the in-degree of a Node.
 		    int operator[](const Key& key) const {
 		      return _deg[key];
+		    }
 		  protected:
 		    typedef typename Digraph::Arc Arc;
 		    virtual void add(const Arc& arc) {
 		      ++_deg[_digraph.target(arc)];
+		    }
 		    virtual void add(const std::vector<Arc>& arcs) {
 		      for (int i = 0; i < int(arcs.size()); ++i) {
 		        ++_deg[_digraph.target(arcs[i])];
+		      }
+		    }
 		    virtual void erase(const Arc& arc) {
 		      --_deg[_digraph.target(arc)];
+		    }
 		    virtual void erase(const std::vector<Arc>& arcs) {
 		      for (int i = 0; i < int(arcs.size()); ++i) {
 		        --_deg[_digraph.target(arcs[i])];
+		      }
+		    }
 		    virtual void build() {
 		      for(typename Digraph::NodeIt it(_digraph); it != INVALID; ++it) {
 		        _deg[it] = countInArcs(_digraph, it);
+		      }
+		    }
 		    virtual void clear() {
 		      for(typename Digraph::NodeIt it(_digraph); it != INVALID; ++it) {
 		        _deg[it] = 0;
+		      }
+		    }
 		  private:
 		    const Digraph& _digraph;
 		    AutoNodeMap _deg;
 		  };
 		  /// \brief Map of the out-degrees of nodes in a digraph.
 		  ///
 		  /// This map returns the out-degree of a node. Once it is constructed,
 		  /// the degrees are stored in a standard \c NodeMap, so each query is done
 		  /// in constant time. On the other hand, the values are updated automatically
 		  /// whenever the digraph changes.
 		  ///
-		  /// \warning Besides \c addNode() and \c addArc(), a digraph structure
 		  /// \warning Besides \c addNode() and \c addArc(), a digraph structure
 		  /// may provide alternative ways to modify the digraph.
 		  /// The correct behavior of OutDegMap is not guarantied if these additional
 		  /// features are used. For example the functions
 		  /// \ref ListDigraph::changeSource() "changeSource()",
 		  /// \ref ListDigraph::changeTarget() "changeTarget()" and
 		  /// \ref ListDigraph::reverseArc() "reverseArc()"
 		  /// of \ref ListDigraph will \e not update the degree values correctly.
 		  ///
 		  /// \sa InDegMap
 		  template <typename GR>
 		  class OutDegMap
 		    : protected ItemSetTraits<GR, typename GR::Arc>
 		      ::ItemNotifier::ObserverBase {
 		  public:
 		    /// The graph type of OutDegMap
 		    typedef GR Graph;
 		    typedef GR Digraph;
 		    /// The key type
 		    typedef typename Digraph::Node Key;
 		    /// The value type
 		    typedef int Value;
 		    typedef typename ItemSetTraits<Digraph, typename Digraph::Arc>
 		    ::ItemNotifier::ObserverBase Parent;
 		  private:
 		    class AutoNodeMap
 		      : public ItemSetTraits<Digraph, Key>::template Map<int>::Type {
 		    public:
 		      typedef typename ItemSetTraits<Digraph, Key>::
 		      template Map<int>::Type Parent;
 		      AutoNodeMap(const Digraph& digraph) : Parent(digraph, 0) {}
 		      virtual void add(const Key& key) {
 		        Parent::add(key);
 		        Parent::set(key, 0);
+		      }
 		      virtual void add(const std::vector<Key>& keys) {
 		        Parent::add(keys);
 		        for (int i = 0; i < int(keys.size()); ++i) {
 		          Parent::set(keys[i], 0);
+		        }
+		      }
 		      virtual void build() {
 		        Parent::build();
 		        Key it;
 		        typename Parent::Notifier* nf = Parent::notifier();
 		        for (nf->first(it); it != INVALID; nf->next(it)) {
 		          Parent::set(it, 0);
+		        }
+		      }
 		    };
 		  public:
 		    /// \brief Constructor.
 		    ///
 		    /// Constructor for creating an out-degree map.
 		    explicit OutDegMap(const Digraph& graph)
 		      : _digraph(graph), _deg(graph) {
 		      Parent::attach(_digraph.notifier(typename Digraph::Arc()));
 		      for(typename Digraph::NodeIt it(_digraph); it != INVALID; ++it) {
 		        _deg[it] = countOutArcs(_digraph, it);
+		      }
+		    }
 		    /// \brief Gives back the out-degree of a Node.
 		    ///
 		    /// Gives back the out-degree of a Node.
 		    int operator[](const Key& key) const {
 		      return _deg[key];
+		    }
 		  protected:
 		    typedef typename Digraph::Arc Arc;
 		    virtual void add(const Arc& arc) {
 		      ++_deg[_digraph.source(arc)];
+		    }
 		    virtual void add(const std::vector<Arc>& arcs) {
 		      for (int i = 0; i < int(arcs.size()); ++i) {
 		        ++_deg[_digraph.source(arcs[i])];
+		      }
+		    }
 		    virtual void erase(const Arc& arc) {
 		      --_deg[_digraph.source(arc)];
+		    }
 		    virtual void erase(const std::vector<Arc>& arcs) {
 		      for (int i = 0; i < int(arcs.size()); ++i) {
 		        --_deg[_digraph.source(arcs[i])];
+		      }
+		    }
 		    virtual void build() {
 		      for(typename Digraph::NodeIt it(_digraph); it != INVALID; ++it) {
 		        _deg[it] = countOutArcs(_digraph, it);
+		      }
+		    }
 		    virtual void clear() {
 		      for(typename Digraph::NodeIt it(_digraph); it != INVALID; ++it) {
 		        _deg[it] = 0;
+		      }
+		    }
 		  private:
 		    const Digraph& _digraph;
 		    AutoNodeMap _deg;
 		  };
 		  /// \brief Potential difference map
 		  ///
 		  /// PotentialDifferenceMap returns the difference between the potentials of
 		  /// the source and target nodes of each arc in a digraph, i.e. it returns
 		  /// \code
 		  ///   potential[gr.target(arc)] - potential[gr.source(arc)].
 		  /// \endcode
 		  /// \tparam GR The digraph type.
 		  /// \tparam POT A node map storing the potentials.
 		  template <typename GR, typename POT>
 		  class PotentialDifferenceMap {
 		  public:
 		    /// Key type
 		    typedef typename GR::Arc Key;
 		    /// Value type
 		    typedef typename POT::Value Value;
 		    /// \brief Constructor
 		    ///
 		    /// Contructor of the map.
 		    explicit PotentialDifferenceMap(const GR& gr,
 		                                    const POT& potential)
 		      : _digraph(gr), _potential(potential) {}
 		    /// \brief Returns the potential difference for the given arc.
 		    ///
 		    /// Returns the potential difference for the given arc, i.e.
 		    /// \code
 		    ///   potential[gr.target(arc)] - potential[gr.source(arc)].
 		    /// \endcode
 		    Value operator[](const Key& arc) const {
 		      return _potential[_digraph.target(arc)] -
 		        _potential[_digraph.source(arc)];
+		    }
 		  private:
 		    const GR& _digraph;
 		    const POT& _potential;
 		  };
 		  /// \brief Returns a PotentialDifferenceMap.
 		  ///
 		  /// This function just returns a PotentialDifferenceMap.
 		  /// \relates PotentialDifferenceMap
 		  template <typename GR, typename POT>
 		  PotentialDifferenceMap<GR, POT>
 		  potentialDifferenceMap(const GR& gr, const POT& potential) {
 		    return PotentialDifferenceMap<GR, POT>(gr, potential);
+		  }
 		  /// @}
+		}
 		#endif // LEMON_MAPS_H

lemon/min_cost_arborescence.h

Show inline comments

@@ -235,514 +235,514 @@
 		        _cost_arcs = new CostArcMap(*_digraph);
+		      }
 		      if (!_heap_cross_ref) {
 		        _heap_cross_ref = new HeapCrossRef(*_digraph, -1);
+		      }
 		      if (!_heap) {
 		        _heap = new Heap(*_heap_cross_ref);
+		      }
+		    }
 		    void destroyStructures() {
 		      if (local_arborescence) {
 		        delete _arborescence;
+		      }
 		      if (local_pred) {
 		        delete _pred;
+		      }
 		      if (_arc_order) {
 		        delete _arc_order;
+		      }
 		      if (_node_order) {
 		        delete _node_order;
+		      }
 		      if (_cost_arcs) {
 		        delete _cost_arcs;
+		      }
 		      if (_heap) {
 		        delete _heap;
+		      }
 		      if (_heap_cross_ref) {
 		        delete _heap_cross_ref;
+		      }
+		    }
 		    Arc prepare(Node node) {
 		      std::vector<Node> nodes;
 		      (*_node_order)[node] = _dual_node_list.size();
 		      StackLevel level;
 		      level.node_level = _dual_node_list.size();
 		      _dual_node_list.push_back(node);
 		      for (InArcIt it(*_digraph, node); it != INVALID; ++it) {
 		        Arc arc = it;
 		        Node source = _digraph->source(arc);
 		        Value value = (*_cost)[it];
 		        if (source == node || (*_node_order)[source] == -3) continue;
 		        if ((*_cost_arcs)[source].arc == INVALID) {
 		          (*_cost_arcs)[source].arc = arc;
 		          (*_cost_arcs)[source].value = value;
 		          nodes.push_back(source);
 		        } else {
 		          if ((*_cost_arcs)[source].value > value) {
 		            (*_cost_arcs)[source].arc = arc;
 		            (*_cost_arcs)[source].value = value;
+		          }
+		        }
+		      }
 		      CostArc minimum = (*_cost_arcs)[nodes[0]];
 		      for (int i = 1; i < int(nodes.size()); ++i) {
 		        if ((*_cost_arcs)[nodes[i]].value < minimum.value) {
 		          minimum = (*_cost_arcs)[nodes[i]];
+		        }
+		      }
 		      (*_arc_order)[minimum.arc] = _dual_variables.size();
 		      DualVariable var(_dual_node_list.size() - 1,
 		                       _dual_node_list.size(), minimum.value);
 		      _dual_variables.push_back(var);
 		      for (int i = 0; i < int(nodes.size()); ++i) {
 		        (*_cost_arcs)[nodes[i]].value -= minimum.value;
 		        level.arcs.push_back((*_cost_arcs)[nodes[i]]);
 		        (*_cost_arcs)[nodes[i]].arc = INVALID;
+		      }
 		      level_stack.push_back(level);
 		      return minimum.arc;
+		    }
 		    Arc contract(Node node) {
 		      int node_bottom = bottom(node);
 		      std::vector<Node> nodes;
 		      while (!level_stack.empty() &&
 		             level_stack.back().node_level >= node_bottom) {
 		        for (int i = 0; i < int(level_stack.back().arcs.size()); ++i) {
 		          Arc arc = level_stack.back().arcs[i].arc;
 		          Node source = _digraph->source(arc);
 		          Value value = level_stack.back().arcs[i].value;
 		          if ((*_node_order)[source] >= node_bottom) continue;
 		          if ((*_cost_arcs)[source].arc == INVALID) {
 		            (*_cost_arcs)[source].arc = arc;
 		            (*_cost_arcs)[source].value = value;
 		            nodes.push_back(source);
 		          } else {
 		            if ((*_cost_arcs)[source].value > value) {
 		              (*_cost_arcs)[source].arc = arc;
 		              (*_cost_arcs)[source].value = value;
+		            }
+		          }
+		        }
 		        level_stack.pop_back();
+		      }
 		      CostArc minimum = (*_cost_arcs)[nodes[0]];
 		      for (int i = 1; i < int(nodes.size()); ++i) {
 		        if ((*_cost_arcs)[nodes[i]].value < minimum.value) {
 		          minimum = (*_cost_arcs)[nodes[i]];
+		        }
+		      }
 		      (*_arc_order)[minimum.arc] = _dual_variables.size();
 		      DualVariable var(node_bottom, _dual_node_list.size(), minimum.value);
 		      _dual_variables.push_back(var);
 		      StackLevel level;
 		      level.node_level = node_bottom;
 		      for (int i = 0; i < int(nodes.size()); ++i) {
 		        (*_cost_arcs)[nodes[i]].value -= minimum.value;
 		        level.arcs.push_back((*_cost_arcs)[nodes[i]]);
 		        (*_cost_arcs)[nodes[i]].arc = INVALID;
+		      }
 		      level_stack.push_back(level);
 		      return minimum.arc;
+		    }
 		    int bottom(Node node) {
 		      int k = level_stack.size() - 1;
 		      while (level_stack[k].node_level > (*_node_order)[node]) {
 		        --k;
+		      }
 		      return level_stack[k].node_level;
+		    }
 		    void finalize(Arc arc) {
 		      Node node = _digraph->target(arc);
 		      _heap->push(node, (*_arc_order)[arc]);
 		      _pred->set(node, arc);
 		      while (!_heap->empty()) {
 		        Node source = _heap->top();
 		        _heap->pop();
 		        (*_node_order)[source] = -1;
 		        for (OutArcIt it(*_digraph, source); it != INVALID; ++it) {
 		          if ((*_arc_order)[it] < 0) continue;
 		          Node target = _digraph->target(it);
 		          switch(_heap->state(target)) {
 		          case Heap::PRE_HEAP:
 		            _heap->push(target, (*_arc_order)[it]);
 		            _pred->set(target, it);
 		            break;
 		          case Heap::IN_HEAP:
 		            if ((*_arc_order)[it] < (*_heap)[target]) {
 		              _heap->decrease(target, (*_arc_order)[it]);
 		              _pred->set(target, it);
+		            }
 		            break;
 		          case Heap::POST_HEAP:
 		            break;
+		          }
+		        }
 		        _arborescence->set((*_pred)[source], true);
+		      }
+		    }
 		  public:
 		    /// \name Named Template Parameters
 		    /// @{
 		    template <class T>
 		    struct SetArborescenceMapTraits : public Traits {
 		      typedef T ArborescenceMap;
 		      static ArborescenceMap *createArborescenceMap(const Digraph &)
+		      {
 		        LEMON_ASSERT(false, "ArborescenceMap is not initialized");
 		        return 0; // ignore warnings
+		      }
 		    };
 		    /// \brief \ref named-templ-param "Named parameter" for
 		    /// setting \c ArborescenceMap type
 		    ///
 		    /// \ref named-templ-param "Named parameter" for setting
 		    /// \c ArborescenceMap type.
 		    /// It must conform to the \ref concepts::WriteMap "WriteMap" concept,
 		    /// and its value type must be \c bool (or convertible).
 		    /// Initially it will be set to \c false on each arc,
 		    /// then it will be set on each arborescence arc once.
 		    template <class T>
 		    struct SetArborescenceMap
 		      : public MinCostArborescence<Digraph, CostMap,
 		                                   SetArborescenceMapTraits<T> > {
 		    };
 		    template <class T>
 		    struct SetPredMapTraits : public Traits {
 		      typedef T PredMap;
 		      static PredMap *createPredMap(const Digraph &)
+		      {
 		        LEMON_ASSERT(false, "PredMap is not initialized");
 		        return 0; // ignore warnings
+		      }
 		    };
 		    /// \brief \ref named-templ-param "Named parameter" for
 		    /// setting \c PredMap type
 		    ///
 		    /// \ref named-templ-param "Named parameter" for setting
 		    /// \c PredMap type.
 		    /// It must meet the \ref concepts::WriteMap "WriteMap" concept,
 		    /// and its value type must be the \c Arc type of the digraph.
 		    template <class T>
 		    struct SetPredMap
 		      : public MinCostArborescence<Digraph, CostMap, SetPredMapTraits<T> > {
 		    };
 		    /// @}
 		    /// \brief Constructor.
 		    ///
 		    /// \param digraph The digraph the algorithm will run on.
 		    /// \param cost The cost map used by the algorithm.
 		    MinCostArborescence(const Digraph& digraph, const CostMap& cost)
 		      : _digraph(&digraph), _cost(&cost), _pred(0), local_pred(false),
 		        _arborescence(0), local_arborescence(false),
 		        _arc_order(0), _node_order(0), _cost_arcs(0),
 		        _heap_cross_ref(0), _heap(0) {}
 		    /// \brief Destructor.
 		    ~MinCostArborescence() {
 		      destroyStructures();
+		    }
 		    /// \brief Sets the arborescence map.
 		    ///
 		    /// Sets the arborescence map.
 		    /// \return <tt>(*this)</tt>
 		    MinCostArborescence& arborescenceMap(ArborescenceMap& m) {
 		      if (local_arborescence) {
 		        delete _arborescence;
+		      }
 		      local_arborescence = false;
 		      _arborescence = &m;
 		      return *this;
+		    }
 		    /// \brief Sets the predecessor map.
 		    ///
 		    /// Sets the predecessor map.
 		    /// \return <tt>(*this)</tt>
 		    MinCostArborescence& predMap(PredMap& m) {
 		      if (local_pred) {
 		        delete _pred;
+		      }
 		      local_pred = false;
 		      _pred = &m;
 		      return *this;
+		    }
 		    /// \name Execution Control
 		    /// The simplest way to execute the algorithm is to use
 		    /// one of the member functions called \c run(...). \n
 		    /// If you need more control on the execution,
 		    /// first you must call \ref init(), then you can add several
 		    /// If you need better control on the execution,
 		    /// you have to call \ref init() first, then you can add several
 		    /// source nodes with \ref addSource().
 		    /// Finally \ref start() will perform the arborescence
 		    /// computation.
 		    ///@{
 		    /// \brief Initializes the internal data structures.
 		    ///
 		    /// Initializes the internal data structures.
 		    ///
 		    void init() {
 		      createStructures();
 		      _heap->clear();
 		      for (NodeIt it(*_digraph); it != INVALID; ++it) {
 		        (*_cost_arcs)[it].arc = INVALID;
 		        (*_node_order)[it] = -3;
 		        (*_heap_cross_ref)[it] = Heap::PRE_HEAP;
 		        _pred->set(it, INVALID);
+		      }
 		      for (ArcIt it(*_digraph); it != INVALID; ++it) {
 		        _arborescence->set(it, false);
 		        (*_arc_order)[it] = -1;
+		      }
 		      _dual_node_list.clear();
 		      _dual_variables.clear();
+		    }
 		    /// \brief Adds a new source node.
 		    ///
 		    /// Adds a new source node to the algorithm.
 		    void addSource(Node source) {
 		      std::vector<Node> nodes;
 		      nodes.push_back(source);
 		      while (!nodes.empty()) {
 		        Node node = nodes.back();
 		        nodes.pop_back();
 		        for (OutArcIt it(*_digraph, node); it != INVALID; ++it) {
 		          Node target = _digraph->target(it);
 		          if ((*_node_order)[target] == -3) {
 		            (*_node_order)[target] = -2;
 		            nodes.push_back(target);
 		            queue.push_back(target);
+		          }
+		        }
+		      }
 		      (*_node_order)[source] = -1;
+		    }
 		    /// \brief Processes the next node in the priority queue.
 		    ///
 		    /// Processes the next node in the priority queue.
 		    ///
 		    /// \return The processed node.
 		    ///
 		    /// \warning The queue must not be empty.
 		    Node processNextNode() {
 		      Node node = queue.back();
 		      queue.pop_back();
 		      if ((*_node_order)[node] == -2) {
 		        Arc arc = prepare(node);
 		        Node source = _digraph->source(arc);
 		        while ((*_node_order)[source] != -1) {
 		          if ((*_node_order)[source] >= 0) {
 		            arc = contract(source);
 		          } else {
 		            arc = prepare(source);
+		          }
 		          source = _digraph->source(arc);
+		        }
 		        finalize(arc);
 		        level_stack.clear();
+		      }
 		      return node;
+		    }
 		    /// \brief Returns the number of the nodes to be processed.
 		    ///
 		    /// Returns the number of the nodes to be processed in the priority
 		    /// queue.
 		    int queueSize() const {
 		      return queue.size();
+		    }
 		    /// \brief Returns \c false if there are nodes to be processed.
 		    ///
 		    /// Returns \c false if there are nodes to be processed.
 		    bool emptyQueue() const {
 		      return queue.empty();
+		    }
 		    /// \brief Executes the algorithm.
 		    ///
 		    /// Executes the algorithm.
 		    ///
 		    /// \pre init() must be called and at least one node should be added
 		    /// with addSource() before using this function.
 		    ///
 		    ///\note mca.start() is just a shortcut of the following code.
 		    ///\code
 		    ///while (!mca.emptyQueue()) {
 		    ///  mca.processNextNode();
 		    ///}
 		    ///\endcode
 		    void start() {
 		      while (!emptyQueue()) {
 		        processNextNode();
+		      }
+		    }
 		    /// \brief Runs %MinCostArborescence algorithm from node \c s.
 		    ///
 		    /// This method runs the %MinCostArborescence algorithm from
 		    /// a root node \c s.
 		    ///
 		    /// \note mca.run(s) is just a shortcut of the following code.
 		    /// \code
 		    /// mca.init();
 		    /// mca.addSource(s);
 		    /// mca.start();
 		    /// \endcode
 		    void run(Node s) {
 		      init();
 		      addSource(s);
 		      start();
+		    }
 		    ///@}
 		    /// \name Query Functions
 		    /// The result of the %MinCostArborescence algorithm can be obtained
 		    /// using these functions.\n
 		    /// Either run() or start() must be called before using them.
 		    /// @{
 		    /// \brief Returns the cost of the arborescence.
 		    ///
 		    /// Returns the cost of the arborescence.
 		    Value arborescenceCost() const {
 		      Value sum = 0;
 		      for (ArcIt it(*_digraph); it != INVALID; ++it) {
 		        if (arborescence(it)) {
 		          sum += (*_cost)[it];
+		        }
+		      }
 		      return sum;
+		    }
 		    /// \brief Returns \c true if the arc is in the arborescence.
 		    ///
 		    /// Returns \c true if the given arc is in the arborescence.
 		    /// \param arc An arc of the digraph.
 		    /// \pre \ref run() must be called before using this function.
 		    bool arborescence(Arc arc) const {
 		      return (*_pred)[_digraph->target(arc)] == arc;
+		    }
 		    /// \brief Returns a const reference to the arborescence map.
 		    ///
 		    /// Returns a const reference to the arborescence map.
 		    /// \pre \ref run() must be called before using this function.
 		    const ArborescenceMap& arborescenceMap() const {
 		      return *_arborescence;
+		    }
 		    /// \brief Returns the predecessor arc of the given node.
 		    ///
 		    /// Returns the predecessor arc of the given node.
 		    /// \pre \ref run() must be called before using this function.
 		    Arc pred(Node node) const {
 		      return (*_pred)[node];
+		    }
 		    /// \brief Returns a const reference to the pred map.
 		    ///
 		    /// Returns a const reference to the pred map.
 		    /// \pre \ref run() must be called before using this function.
 		    const PredMap& predMap() const {
 		      return *_pred;
+		    }
 		    /// \brief Indicates that a node is reachable from the sources.
 		    ///
 		    /// Indicates that a node is reachable from the sources.
 		    bool reached(Node node) const {
 		      return (*_node_order)[node] != -3;
+		    }
 		    /// \brief Indicates that a node is processed.
 		    ///
 		    /// Indicates that a node is processed. The arborescence path exists
 		    /// from the source to the given node.
 		    bool processed(Node node) const {
 		      return (*_node_order)[node] == -1;
+		    }
 		    /// \brief Returns the number of the dual variables in basis.
 		    ///
 		    /// Returns the number of the dual variables in basis.
 		    int dualNum() const {
 		      return _dual_variables.size();
+		    }
 		    /// \brief Returns the value of the dual solution.
 		    ///
 		    /// Returns the value of the dual solution. It should be
 		    /// equal to the arborescence value.
 		    Value dualValue() const {
 		      Value sum = 0;
 		      for (int i = 0; i < int(_dual_variables.size()); ++i) {
 		        sum += _dual_variables[i].value;
+		      }
 		      return sum;
+		    }
 		    /// \brief Returns the number of the nodes in the dual variable.
 		    ///
 		    /// Returns the number of the nodes in the dual variable.
 		    int dualSize(int k) const {
 		      return _dual_variables[k].end - _dual_variables[k].begin;
+		    }
 		    /// \brief Returns the value of the dual variable.
 		    ///
 		    /// Returns the the value of the dual variable.
 		    Value dualValue(int k) const {
 		      return _dual_variables[k].value;
+		    }
 		    /// \brief LEMON iterator for getting a dual variable.
 		    ///
 		    /// This class provides a common style LEMON iterator for getting a
 		    /// dual variable of \ref MinCostArborescence algorithm.
 		    /// It iterates over a subset of the nodes.
 		    class DualIt {
 		    public:
 		      /// \brief Constructor.
 		      ///
 		      /// Constructor for getting the nodeset of the dual variable
 		      /// of \ref MinCostArborescence algorithm.
 		      DualIt(const MinCostArborescence& algorithm, int variable)
 		        : _algorithm(&algorithm)
+		      {
 		        _index = _algorithm->_dual_variables[variable].begin;
 		        _last = _algorithm->_dual_variables[variable].end;
+		      }
 		      /// \brief Conversion to \c Node.
 		      ///
 		      /// Conversion to \c Node.
 		      operator Node() const {
 		        return _algorithm->_dual_node_list[_index];
+		      }
 		      /// \brief Increment operator.

lemon/preflow.h

Show inline comments

 		/* -*- mode: C++; indent-tabs-mode: nil; -*-
+		 *
 		 * This file is a part of LEMON, a generic C++ optimization library.
+		 *
 		 * 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_PREFLOW_H
 		#define LEMON_PREFLOW_H
 		#include <lemon/tolerance.h>
 		#include <lemon/elevator.h>
 		/// \file
 		/// \ingroup max_flow
 		/// \brief Implementation of the preflow algorithm.
 		namespace lemon {
 		  /// \brief Default traits class of Preflow class.
 		  ///
 		  /// Default traits class of Preflow class.
 		  /// \tparam GR Digraph type.
 		  /// \tparam CAP Capacity map type.
 		  template <typename GR, typename CAP>
 		  struct PreflowDefaultTraits {
 		    /// \brief The type of the digraph the algorithm runs on.
 		    typedef GR Digraph;
 		    /// \brief The type of the map that stores the arc capacities.
 		    ///
 		    /// The type of the map that stores the arc capacities.
 		    /// It must meet the \ref concepts::ReadMap "ReadMap" concept.
 		    typedef CAP CapacityMap;
 		    /// \brief The type of the flow values.
 		    typedef typename CapacityMap::Value Value;
 		    /// \brief The type of the map that stores the flow values.
 		    ///
 		    /// The type of the map that stores the flow values.
 		    /// It must meet the \ref concepts::ReadWriteMap "ReadWriteMap" concept.
 		#ifdef DOXYGEN
 		    typedef GR::ArcMap<Value> FlowMap;
 		#else
 		    typedef typename Digraph::template ArcMap<Value> FlowMap;
 		#endif
 		    /// \brief Instantiates a FlowMap.
 		    ///
 		    /// This function instantiates a \ref FlowMap.
 		    /// \param digraph The digraph for which we would like to define
 		    /// the flow map.
 		    static FlowMap* createFlowMap(const Digraph& digraph) {
 		      return new FlowMap(digraph);
+		    }
 		    /// \brief The elevator type used by Preflow algorithm.
 		    ///
 		    /// The elevator type used by Preflow algorithm.
 		    ///
 		    /// \sa Elevator
 		    /// \sa LinkedElevator
-		    typedef LinkedElevator<Digraph, typename Digraph::Node> Elevator;
+		    /// \sa Elevator, LinkedElevator
 		#ifdef DOXYGEN
 		    typedef lemon::Elevator<GR, GR::Node> Elevator;
 		#else
 		    typedef lemon::Elevator<Digraph, typename Digraph::Node> Elevator;
 		#endif
 		    /// \brief Instantiates an Elevator.
 		    ///
 		    /// This function instantiates an \ref Elevator.
 		    /// \param digraph The digraph for which we would like to define
 		    /// the elevator.
 		    /// \param max_level The maximum level of the elevator.
 		    static Elevator* createElevator(const Digraph& digraph, int max_level) {
 		      return new Elevator(digraph, max_level);
+		    }
 		    /// \brief The tolerance used by the algorithm
 		    ///
 		    /// The tolerance used by the algorithm to handle inexact computation.
 		    typedef lemon::Tolerance<Value> Tolerance;
 		  };
 		  /// \ingroup max_flow
 		  ///
 		  /// \brief %Preflow algorithm class.
 		  ///
 		  /// This class provides an implementation of Goldberg-Tarjan's \e preflow
 		  /// \e push-relabel algorithm producing a \ref max_flow
 		  /// "flow of maximum value" in a digraph.
 		  /// The preflow algorithms are the fastest known maximum
-		  /// flow algorithms. The current implementation use a mixture of the
+		  /// flow algorithms. The current implementation uses a mixture of the
 		  /// \e "highest label" and the \e "bound decrease" heuristics.
 		  /// The worst case time complexity of the algorithm is \f$O(n^2\sqrt{e})\f$.
 		  ///
 		  /// The algorithm consists of two phases. After the first phase
 		  /// the maximum flow value and the minimum cut is obtained. The
 		  /// second phase constructs a feasible maximum flow on each arc.
 		  ///
 		  /// \tparam GR The type of the digraph the algorithm runs on.
 		  /// \tparam CAP The type of the capacity map. The default map
 		  /// type is \ref concepts::Digraph::ArcMap "GR::ArcMap<int>".
 		#ifdef DOXYGEN
 		  template <typename GR, typename CAP, typename TR>
 		#else
 		  template <typename GR,
 		            typename CAP = typename GR::template ArcMap<int>,
 		            typename TR = PreflowDefaultTraits<GR, CAP> >
 		#endif
 		  class Preflow {
 		  public:
 		    ///The \ref PreflowDefaultTraits "traits class" of the algorithm.
 		    typedef TR Traits;
 		    ///The type of the digraph the algorithm runs on.
 		    typedef typename Traits::Digraph Digraph;
 		    ///The type of the capacity map.
 		    typedef typename Traits::CapacityMap CapacityMap;
 		    ///The type of the flow values.
 		    typedef typename Traits::Value Value;
 		    ///The type of the flow map.
 		    typedef typename Traits::FlowMap FlowMap;
 		    ///The type of the elevator.
 		    typedef typename Traits::Elevator Elevator;
 		    ///The type of the tolerance.
 		    typedef typename Traits::Tolerance Tolerance;
 		  private:
 		    TEMPLATE_DIGRAPH_TYPEDEFS(Digraph);
 		    const Digraph& _graph;
 		    const CapacityMap* _capacity;
 		    int _node_num;
 		    Node _source, _target;
 		    FlowMap* _flow;
 		    bool _local_flow;
 		    Elevator* _level;
 		    bool _local_level;
 		    typedef typename Digraph::template NodeMap<Value> ExcessMap;
 		    ExcessMap* _excess;
 		    Tolerance _tolerance;
 		    bool _phase;
 		    void createStructures() {
 		      _node_num = countNodes(_graph);
 		      if (!_flow) {
 		        _flow = Traits::createFlowMap(_graph);
 		        _local_flow = true;
+		      }
 		      if (!_level) {
 		        _level = Traits::createElevator(_graph, _node_num);
 		        _local_level = true;
+		      }
 		      if (!_excess) {
 		        _excess = new ExcessMap(_graph);
+		      }
+		    }
 		    void destroyStructures() {
 		      if (_local_flow) {
 		        delete _flow;
+		      }
 		      if (_local_level) {
 		        delete _level;
+		      }
 		      if (_excess) {
 		        delete _excess;
+		      }
+		    }
 		  public:
 		    typedef Preflow Create;
 		    ///\name Named Template Parameters
 		    ///@{
 		    template <typename T>
 		    struct SetFlowMapTraits : public Traits {
 		      typedef T FlowMap;
 		      static FlowMap *createFlowMap(const Digraph&) {
 		        LEMON_ASSERT(false, "FlowMap is not initialized");
 		        return 0; // ignore warnings
+		      }
 		    };
 		    /// \brief \ref named-templ-param "Named parameter" for setting
 		    /// FlowMap type
 		    ///
 		    /// \ref named-templ-param "Named parameter" for setting FlowMap
 		    /// type.
 		    template <typename T>
 		    struct SetFlowMap
 		      : public Preflow<Digraph, CapacityMap, SetFlowMapTraits<T> > {
 		      typedef Preflow<Digraph, CapacityMap,
 		                      SetFlowMapTraits<T> > Create;
 		    };
 		    template <typename T>
 		    struct SetElevatorTraits : public Traits {
 		      typedef T Elevator;
 		      static Elevator *createElevator(const Digraph&, int) {
 		        LEMON_ASSERT(false, "Elevator is not initialized");
 		        return 0; // ignore warnings
+		      }
 		    };
 		    /// \brief \ref named-templ-param "Named parameter" for setting
 		    /// Elevator type
 		    ///
 		    /// \ref named-templ-param "Named parameter" for setting Elevator
 		    /// type. If this named parameter is used, then an external
 		    /// elevator object must be passed to the algorithm using the
 		    /// \ref elevator(Elevator&) "elevator()" function before calling
 		    /// \ref run() or \ref init().
 		    /// \sa SetStandardElevator
 		    template <typename T>
 		    struct SetElevator
 		      : public Preflow<Digraph, CapacityMap, SetElevatorTraits<T> > {
 		      typedef Preflow<Digraph, CapacityMap,
 		                      SetElevatorTraits<T> > Create;
 		    };
 		    template <typename T>
 		    struct SetStandardElevatorTraits : public Traits {
 		      typedef T Elevator;
 		      static Elevator *createElevator(const Digraph& digraph, int max_level) {
 		        return new Elevator(digraph, max_level);
+		      }
 		    };
 		    /// \brief \ref named-templ-param "Named parameter" for setting
 		    /// Elevator type with automatic allocation
 		    ///
 		    /// \ref named-templ-param "Named parameter" for setting Elevator
 		    /// type with automatic allocation.
 		    /// The Elevator should have standard constructor interface to be
 		    /// able to automatically created by the algorithm (i.e. the
 		    /// digraph and the maximum level should be passed to it).
 		    /// However an external elevator object could also be passed to the
 		    /// algorithm with the \ref elevator(Elevator&) "elevator()" function
 		    /// before calling \ref run() or \ref init().
 		    /// \sa SetElevator
 		    template <typename T>
 		    struct SetStandardElevator
 		      : public Preflow<Digraph, CapacityMap,
 		                       SetStandardElevatorTraits<T> > {
 		      typedef Preflow<Digraph, CapacityMap,
 		                      SetStandardElevatorTraits<T> > Create;
 		    };
 		    /// @}
 		  protected:
 		    Preflow() {}
 		  public:
 		    /// \brief The constructor of the class.
 		    ///
 		    /// The constructor of the class.
 		    /// \param digraph The digraph the algorithm runs on.
 		    /// \param capacity The capacity of the arcs.
 		    /// \param source The source node.
 		    /// \param target The target node.
 		    Preflow(const Digraph& digraph, const CapacityMap& capacity,
 		            Node source, Node target)
 		      : _graph(digraph), _capacity(&capacity),
 		        _node_num(0), _source(source), _target(target),
 		        _flow(0), _local_flow(false),
 		        _level(0), _local_level(false),
 		        _excess(0), _tolerance(), _phase() {}
 		    /// \brief Destructor.
 		    ///
 		    /// Destructor.
 		    ~Preflow() {
 		      destroyStructures();
+		    }
 		    /// \brief Sets the capacity map.
 		    ///
 		    /// Sets the capacity map.
 		    /// \return <tt>(*this)</tt>
 		    Preflow& capacityMap(const CapacityMap& map) {
 		      _capacity = &map;
 		      return *this;
+		    }
 		    /// \brief Sets the flow map.
 		    ///
 		    /// Sets the flow map.
 		    /// If you don't use this function before calling \ref run() or
 		    /// \ref init(), an instance will be allocated automatically.
 		    /// The destructor deallocates this automatically allocated map,
 		    /// of course.
 		    /// \return <tt>(*this)</tt>
 		    Preflow& flowMap(FlowMap& map) {
 		      if (_local_flow) {
 		        delete _flow;
 		        _local_flow = false;
+		      }
 		      _flow = &map;
 		      return *this;
+		    }
 		    /// \brief Sets the source node.
 		    ///
 		    /// Sets the source node.
 		    /// \return <tt>(*this)</tt>
 		    Preflow& source(const Node& node) {
 		      _source = node;
 		      return *this;
+		    }
 		    /// \brief Sets the target node.
 		    ///
 		    /// Sets the target node.
 		    /// \return <tt>(*this)</tt>
 		    Preflow& target(const Node& node) {
 		      _target = node;
 		      return *this;
+		    }
 		    /// \brief Sets the elevator used by algorithm.
 		    ///
 		    /// Sets the elevator used by algorithm.
 		    /// If you don't use this function before calling \ref run() or
 		    /// \ref init(), an instance will be allocated automatically.
 		    /// The destructor deallocates this automatically allocated elevator,
 		    /// of course.
 		    /// \return <tt>(*this)</tt>
 		    Preflow& elevator(Elevator& elevator) {
 		      if (_local_level) {
 		        delete _level;
 		        _local_level = false;
+		      }
 		      _level = &elevator;
 		      return *this;
+		    }
 		    /// \brief Returns a const reference to the elevator.
 		    ///
 		    /// Returns a const reference to the elevator.
 		    ///
 		    /// \pre Either \ref run() or \ref init() must be called before
 		    /// using this function.
 		    const Elevator& elevator() const {
 		      return *_level;
+		    }
 		    /// \brief Sets the tolerance used by algorithm.
+		    /// \brief Sets the tolerance used by the algorithm.
 		    ///
 		    /// Sets the tolerance used by algorithm.
 		    Preflow& tolerance(const Tolerance& tolerance) const {
 		    /// Sets the tolerance object used by the algorithm.
 		    /// \return <tt>(*this)</tt>
 		    Preflow& tolerance(const Tolerance& tolerance) {
 		      _tolerance = tolerance;
 		      return *this;
+		    }
 		    /// \brief Returns a const reference to the tolerance.
 		    ///
-		    /// Returns a const reference to the tolerance.
+		    /// Returns a const reference to the tolerance object used by
 		    /// the algorithm.
 		    const Tolerance& tolerance() const {
-		      return tolerance;
+		      return _tolerance;
+		    }
 		    /// \name Execution Control
 		    /// The simplest way to execute the preflow algorithm is to use
 		    /// \ref run() or \ref runMinCut().\n
 		    /// If you need more control on the initial solution or the execution,
 		    /// first you have to call one of the \ref init() functions, then
 		    /// If you need better control on the initial solution or the execution,
 		    /// you have to call one of the \ref init() functions first, then
 		    /// \ref startFirstPhase() and if you need it \ref startSecondPhase().
 		    ///@{
 		    /// \brief Initializes the internal data structures.
 		    ///
 		    /// Initializes the internal data structures and sets the initial
 		    /// flow to zero on each arc.
 		    void init() {
 		      createStructures();
 		      _phase = true;
 		      for (NodeIt n(_graph); n != INVALID; ++n) {
 		        (*_excess)[n] = 0;
+		      }
 		      for (ArcIt e(_graph); e != INVALID; ++e) {
 		        _flow->set(e, 0);
+		      }
 		      typename Digraph::template NodeMap<bool> reached(_graph, false);
 		      _level->initStart();
 		      _level->initAddItem(_target);
 		      std::vector<Node> queue;
 		      reached[_source] = true;
 		      queue.push_back(_target);
 		      reached[_target] = true;
 		      while (!queue.empty()) {
 		        _level->initNewLevel();
 		        std::vector<Node> nqueue;
 		        for (int i = 0; i < int(queue.size()); ++i) {
 		          Node n = queue[i];
 		          for (InArcIt e(_graph, n); e != INVALID; ++e) {
 		            Node u = _graph.source(e);
 		            if (!reached[u] && _tolerance.positive((*_capacity)[e])) {
 		              reached[u] = true;
 		              _level->initAddItem(u);
 		              nqueue.push_back(u);
+		            }
+		          }
+		        }
 		        queue.swap(nqueue);
+		      }
 		      _level->initFinish();
 		      for (OutArcIt e(_graph, _source); e != INVALID; ++e) {
 		        if (_tolerance.positive((*_capacity)[e])) {
 		          Node u = _graph.target(e);
 		          if ((*_level)[u] == _level->maxLevel()) continue;
 		          _flow->set(e, (*_capacity)[e]);
 		          (*_excess)[u] += (*_capacity)[e];
 		          if (u != _target && !_level->active(u)) {
 		            _level->activate(u);
+		          }
+		        }
+		      }
+		    }
 		    /// \brief Initializes the internal data structures using the
 		    /// given flow map.
 		    ///
 		    /// Initializes the internal data structures and sets the initial
 		    /// flow to the given \c flowMap. The \c flowMap should contain a
 		    /// flow or at least a preflow, i.e. at each node excluding the
 		    /// source node the incoming flow should greater or equal to the
 		    /// outgoing flow.
 		    /// \return \c false if the given \c flowMap is not a preflow.
 		    template <typename FlowMap>
 		    bool init(const FlowMap& flowMap) {
 		      createStructures();
 		      for (ArcIt e(_graph); e != INVALID; ++e) {
 		        _flow->set(e, flowMap[e]);
+		      }
 		      for (NodeIt n(_graph); n != INVALID; ++n) {
 		        Value excess = 0;
 		        for (InArcIt e(_graph, n); e != INVALID; ++e) {
 		          excess += (*_flow)[e];
+		        }
 		        for (OutArcIt e(_graph, n); e != INVALID; ++e) {
 		          excess -= (*_flow)[e];
+		        }
 		        if (excess < 0 && n != _source) return false;
 		        (*_excess)[n] = excess;
+		      }
 		      typename Digraph::template NodeMap<bool> reached(_graph, false);
 		      _level->initStart();
 		      _level->initAddItem(_target);
 		      std::vector<Node> queue;
 		      reached[_source] = true;
 		      queue.push_back(_target);
 		      reached[_target] = true;
 		      while (!queue.empty()) {
 		        _level->initNewLevel();
 		        std::vector<Node> nqueue;
 		        for (int i = 0; i < int(queue.size()); ++i) {
 		          Node n = queue[i];
 		          for (InArcIt e(_graph, n); e != INVALID; ++e) {
 		            Node u = _graph.source(e);
 		            if (!reached[u] &&
 		                _tolerance.positive((*_capacity)[e] - (*_flow)[e])) {
 		              reached[u] = true;
 		              _level->initAddItem(u);
 		              nqueue.push_back(u);
+		            }
+		          }
 		          for (OutArcIt e(_graph, n); e != INVALID; ++e) {
 		            Node v = _graph.target(e);
 		            if (!reached[v] && _tolerance.positive((*_flow)[e])) {
 		              reached[v] = true;
 		              _level->initAddItem(v);
 		              nqueue.push_back(v);
+		            }
+		          }
+		        }
 		        queue.swap(nqueue);
+		      }
 		      _level->initFinish();
 		      for (OutArcIt e(_graph, _source); e != INVALID; ++e) {
 		        Value rem = (*_capacity)[e] - (*_flow)[e];
 		        if (_tolerance.positive(rem)) {
 		          Node u = _graph.target(e);
 		          if ((*_level)[u] == _level->maxLevel()) continue;
 		          _flow->set(e, (*_capacity)[e]);
 		          (*_excess)[u] += rem;
 		          if (u != _target && !_level->active(u)) {
 		            _level->activate(u);
+		          }
+		        }
+		      }
 		      for (InArcIt e(_graph, _source); e != INVALID; ++e) {
 		        Value rem = (*_flow)[e];
 		        if (_tolerance.positive(rem)) {
 		          Node v = _graph.source(e);
 		          if ((*_level)[v] == _level->maxLevel()) continue;
 		          _flow->set(e, 0);
 		          (*_excess)[v] += rem;
 		          if (v != _target && !_level->active(v)) {
 		            _level->activate(v);
+		          }
+		        }
+		      }
 		      return true;
+		    }
 		    /// \brief Starts the first phase of the preflow algorithm.
 		    ///
 		    /// The preflow algorithm consists of two phases, this method runs
 		    /// the first phase. After the first phase the maximum flow value
 		    /// and a minimum value cut can already be computed, although a
 		    /// maximum flow is not yet obtained. So after calling this method
 		    /// \ref flowValue() returns the value of a maximum flow and \ref
 		    /// minCut() returns a minimum cut.
 		    /// \pre One of the \ref init() functions must be called before
 		    /// using this function.
 		    void startFirstPhase() {
 		      _phase = true;
 		      Node n = _level->highestActive();
 		      int level = _level->highestActiveLevel();
 		      while (n != INVALID) {
 		        int num = _node_num;
 		        while (num > 0 && n != INVALID) {
 		          Value excess = (*_excess)[n];
 		          int new_level = _level->maxLevel();
 		          for (OutArcIt e(_graph, n); e != INVALID; ++e) {
 		            Value rem = (*_capacity)[e] - (*_flow)[e];
 		            if (!_tolerance.positive(rem)) continue;
 		            Node v = _graph.target(e);
 		            if ((*_level)[v] < level) {
 		              if (!_level->active(v) && v != _target) {
 		                _level->activate(v);
+		              }
 		              if (!_tolerance.less(rem, excess)) {
 		                _flow->set(e, (*_flow)[e] + excess);
 		                (*_excess)[v] += excess;
 		                excess = 0;
 		                goto no_more_push_1;
 		              } else {
 		                excess -= rem;
 		                (*_excess)[v] += rem;
 		                _flow->set(e, (*_capacity)[e]);
+		              }
 		            } else if (new_level > (*_level)[v]) {
 		              new_level = (*_level)[v];
+		            }
+		          }
 		          for (InArcIt e(_graph, n); e != INVALID; ++e) {
 		            Value rem = (*_flow)[e];
 		            if (!_tolerance.positive(rem)) continue;
 		            Node v = _graph.source(e);
 		            if ((*_level)[v] < level) {
 		              if (!_level->active(v) && v != _target) {
 		                _level->activate(v);
+		              }
 		              if (!_tolerance.less(rem, excess)) {
 		                _flow->set(e, (*_flow)[e] - excess);
 		                (*_excess)[v] += excess;
 		                excess = 0;
 		                goto no_more_push_1;
 		              } else {
 		                excess -= rem;
 		                (*_excess)[v] += rem;
 		                _flow->set(e, 0);
+		              }
 		            } else if (new_level > (*_level)[v]) {
 		              new_level = (*_level)[v];
+		            }
+		          }
 		        no_more_push_1:
 		          (*_excess)[n] = excess;
 		          if (excess != 0) {
 		            if (new_level + 1 < _level->maxLevel()) {
 		              _level->liftHighestActive(new_level + 1);
 		            } else {
 		              _level->liftHighestActiveToTop();
+		            }
 		            if (_level->emptyLevel(level)) {
 		              _level->liftToTop(level);
+		            }
 		          } else {
 		            _level->deactivate(n);
+		          }
 		          n = _level->highestActive();
 		          level = _level->highestActiveLevel();
 		          --num;
+		        }
 		        num = _node_num * 20;
 		        while (num > 0 && n != INVALID) {
 		          Value excess = (*_excess)[n];
 		          int new_level = _level->maxLevel();
 		          for (OutArcIt e(_graph, n); e != INVALID; ++e) {
 		            Value rem = (*_capacity)[e] - (*_flow)[e];
 		            if (!_tolerance.positive(rem)) continue;
 		            Node v = _graph.target(e);
 		            if ((*_level)[v] < level) {
 		              if (!_level->active(v) && v != _target) {
 		                _level->activate(v);

test/CMakeLists.txt

Show inline comments

 		INCLUDE_DIRECTORIES(
 		  ${PROJECT_SOURCE_DIR}
 		  ${PROJECT_BINARY_DIR}
+		)
 		LINK_DIRECTORIES(
 		  ${PROJECT_BINARY_DIR}/lemon
+		)
 		SET(TESTS
 		  adaptors_test
 		  bellman_ford_test
 		  bfs_test
 		  circulation_test
 		  connectivity_test
 		  counter_test
 		  dfs_test
 		  digraph_test
 		  dijkstra_test
 		  dim_test
 		  edge_set_test
 		  error_test
 		  euler_test
 		  gomory_hu_test
 		  graph_copy_test
 		  graph_test
 		  graph_utils_test
 		  hao_orlin_test
 		  heap_test
 		  kruskal_test
 		  maps_test
 		  matching_test
 		  min_cost_arborescence_test
 		  min_cost_flow_test
 		  path_test
 		  preflow_test
 		  radix_sort_test
 		  random_test
 		  suurballe_test
 		  time_measure_test
 		  unionfind_test
+		)
 		IF(LEMON_HAVE_LP)
 		  ADD_EXECUTABLE(lp_test lp_test.cc)
 		  SET(LP_TEST_LIBS lemon)
 		  IF(LEMON_HAVE_GLPK)
 		    SET(LP_TEST_LIBS ${LP_TEST_LIBS} ${GLPK_LIBRARIES})
 		  ENDIF()
 		  IF(LEMON_HAVE_CPLEX)
 		    SET(LP_TEST_LIBS ${LP_TEST_LIBS} ${CPLEX_LIBRARIES})
 		  ENDIF()
 		  IF(LEMON_HAVE_CLP)
 		    SET(LP_TEST_LIBS ${LP_TEST_LIBS} ${COIN_CLP_LIBRARIES})
 		  ENDIF()
 		  TARGET_LINK_LIBRARIES(lp_test ${LP_TEST_LIBS})
 		  ADD_TEST(lp_test lp_test)
 		  IF(WIN32 AND LEMON_HAVE_GLPK)
 		    GET_TARGET_PROPERTY(TARGET_LOC lp_test LOCATION)
 		    GET_FILENAME_COMPONENT(TARGET_PATH ${TARGET_LOC} PATH)
 		    ADD_CUSTOM_COMMAND(TARGET lp_test POST_BUILD
 		      COMMAND ${CMAKE_COMMAND} -E copy ${GLPK_BIN_DIR}/glpk.dll ${TARGET_PATH}
 		      COMMAND ${CMAKE_COMMAND} -E copy ${GLPK_BIN_DIR}/libltdl3.dll ${TARGET_PATH}
 		      COMMAND ${CMAKE_COMMAND} -E copy ${GLPK_BIN_DIR}/zlib1.dll ${TARGET_PATH}
+		    )
 		  ENDIF()
 		  IF(WIN32 AND LEMON_HAVE_CPLEX)
 		    GET_TARGET_PROPERTY(TARGET_LOC lp_test LOCATION)
 		    GET_FILENAME_COMPONENT(TARGET_PATH ${TARGET_LOC} PATH)
 		    ADD_CUSTOM_COMMAND(TARGET lp_test POST_BUILD
 		      COMMAND ${CMAKE_COMMAND} -E copy ${CPLEX_BIN_DIR}/cplex91.dll ${TARGET_PATH}
+		    )
 		  ENDIF()
 		ENDIF()
 		IF(LEMON_HAVE_MIP)
 		  ADD_EXECUTABLE(mip_test mip_test.cc)
 		  SET(MIP_TEST_LIBS lemon)
 		  IF(LEMON_HAVE_GLPK)
 		    SET(MIP_TEST_LIBS ${MIP_TEST_LIBS} ${GLPK_LIBRARIES})
 		  ENDIF()
 		  IF(LEMON_HAVE_CPLEX)
 		    SET(MIP_TEST_LIBS ${MIP_TEST_LIBS} ${CPLEX_LIBRARIES})
 		  ENDIF()
 		  IF(LEMON_HAVE_CBC)
 		    SET(MIP_TEST_LIBS ${MIP_TEST_LIBS} ${COIN_CBC_LIBRARIES})
 		  ENDIF()
 		  TARGET_LINK_LIBRARIES(mip_test ${MIP_TEST_LIBS})
 		  ADD_TEST(mip_test mip_test)
 		  IF(WIN32 AND LEMON_HAVE_GLPK)
 		    GET_TARGET_PROPERTY(TARGET_LOC mip_test LOCATION)
 		    GET_FILENAME_COMPONENT(TARGET_PATH ${TARGET_LOC} PATH)
 		    ADD_CUSTOM_COMMAND(TARGET mip_test POST_BUILD
 		      COMMAND ${CMAKE_COMMAND} -E copy ${GLPK_BIN_DIR}/glpk.dll ${TARGET_PATH}
 		      COMMAND ${CMAKE_COMMAND} -E copy ${GLPK_BIN_DIR}/libltdl3.dll ${TARGET_PATH}
 		      COMMAND ${CMAKE_COMMAND} -E copy ${GLPK_BIN_DIR}/zlib1.dll ${TARGET_PATH}
+		    )
 		  ENDIF()
 		  IF(WIN32 AND LEMON_HAVE_CPLEX)
 		    GET_TARGET_PROPERTY(TARGET_LOC mip_test LOCATION)
 		    GET_FILENAME_COMPONENT(TARGET_PATH ${TARGET_LOC} PATH)
 		    ADD_CUSTOM_COMMAND(TARGET mip_test POST_BUILD
 		      COMMAND ${CMAKE_COMMAND} -E copy ${CPLEX_BIN_DIR}/cplex91.dll ${TARGET_PATH}
+		    )
 		  ENDIF()
 		ENDIF()
 		FOREACH(TEST_NAME ${TESTS})
 		  ADD_EXECUTABLE(${TEST_NAME} ${TEST_NAME}.cc)
 		  TARGET_LINK_LIBRARIES(${TEST_NAME} lemon)
 		  ADD_TEST(${TEST_NAME} ${TEST_NAME})
 		ENDFOREACH()

test/Makefile.am

Show inline comments

 		EXTRA_DIST += \
 			test/CMakeLists.txt
 		noinst_HEADERS += \
 			test/graph_test.h \
 			test/test_tools.h
 		check_PROGRAMS += \
 			test/adaptors_test \
 			test/bellman_ford_test \
 			test/bfs_test \
 			test/circulation_test \
 			test/connectivity_test \
 			test/counter_test \
 			test/dfs_test \
 			test/digraph_test \
 			test/dijkstra_test \
 			test/dim_test \
 			test/edge_set_test \
 			test/error_test \
 			test/euler_test \
 			test/gomory_hu_test \
 			test/graph_copy_test \
 			test/graph_test \
 			test/graph_utils_test \
 			test/hao_orlin_test \
 			test/heap_test \
 			test/kruskal_test \
 			test/maps_test \
 			test/matching_test \
 			test/min_cost_arborescence_test \
 			test/min_cost_flow_test \
 			test/path_test \
 			test/preflow_test \
 			test/radix_sort_test \
 			test/random_test \
 			test/suurballe_test \
 			test/test_tools_fail \
 			test/test_tools_pass \
 			test/time_measure_test \
 			test/unionfind_test
 		test_test_tools_pass_DEPENDENCIES = demo
 		if HAVE_LP
 		check_PROGRAMS += test/lp_test
 		endif HAVE_LP
 		if HAVE_MIP
 		check_PROGRAMS += test/mip_test
 		endif HAVE_MIP
 		TESTS += $(check_PROGRAMS)
 		XFAIL_TESTS += test/test_tools_fail$(EXEEXT)
 		test_adaptors_test_SOURCES = test/adaptors_test.cc
 		test_bellman_ford_test_SOURCES = test/bellman_ford_test.cc
 		test_bfs_test_SOURCES = test/bfs_test.cc
 		test_circulation_test_SOURCES = test/circulation_test.cc
 		test_counter_test_SOURCES = test/counter_test.cc
 		test_connectivity_test_SOURCES = test/connectivity_test.cc
 		test_dfs_test_SOURCES = test/dfs_test.cc
 		test_digraph_test_SOURCES = test/digraph_test.cc
 		test_dijkstra_test_SOURCES = test/dijkstra_test.cc
 		test_dim_test_SOURCES = test/dim_test.cc
 		test_edge_set_test_SOURCES = test/edge_set_test.cc
 		test_error_test_SOURCES = test/error_test.cc
 		test_euler_test_SOURCES = test/euler_test.cc
 		test_gomory_hu_test_SOURCES = test/gomory_hu_test.cc
 		test_graph_copy_test_SOURCES = test/graph_copy_test.cc
 		test_graph_test_SOURCES = test/graph_test.cc
 		test_graph_utils_test_SOURCES = test/graph_utils_test.cc
 		test_heap_test_SOURCES = test/heap_test.cc
 		test_kruskal_test_SOURCES = test/kruskal_test.cc
 		test_hao_orlin_test_SOURCES = test/hao_orlin_test.cc
 		test_lp_test_SOURCES = test/lp_test.cc
 		test_maps_test_SOURCES = test/maps_test.cc
 		test_mip_test_SOURCES = test/mip_test.cc
 		test_matching_test_SOURCES = test/matching_test.cc
 		test_min_cost_arborescence_test_SOURCES = test/min_cost_arborescence_test.cc
 		test_min_cost_flow_test_SOURCES = test/min_cost_flow_test.cc
 		test_path_test_SOURCES = test/path_test.cc
 		test_preflow_test_SOURCES = test/preflow_test.cc
 		test_radix_sort_test_SOURCES = test/radix_sort_test.cc
 		test_suurballe_test_SOURCES = test/suurballe_test.cc
 		test_random_test_SOURCES = test/random_test.cc
 		test_test_tools_fail_SOURCES = test/test_tools_fail.cc
 		test_test_tools_pass_SOURCES = test/test_tools_pass.cc
 		test_time_measure_test_SOURCES = test/time_measure_test.cc
 		test_unionfind_test_SOURCES = test/unionfind_test.cc

test/circulation_test.cc

Show inline comments

 		/* -*- mode: C++; indent-tabs-mode: nil; -*-
+		 *
 		 * This file is a part of LEMON, a generic C++ optimization library.
+		 *
 		 * 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.
+		 *
 		 */
 		#include <iostream>
 		#include "test_tools.h"
 		#include <lemon/list_graph.h>
 		#include <lemon/circulation.h>
 		#include <lemon/lgf_reader.h>
 		#include <lemon/concepts/digraph.h>
 		#include <lemon/concepts/maps.h>
 		using namespace lemon;
 		char test_lgf[] =
 		  "@nodes\n"
 		  "label\n"
 		  "0\n"
 		  "1\n"
 		  "2\n"
 		  "3\n"
 		  "4\n"
 		  "5\n"
 		  "@arcs\n"
 		  "     lcap  ucap\n"
 		  "0 1  2  10\n"
 		  "0 2  2  6\n"
 		  "1 3  4  7\n"
 		  "1 4  0  5\n"
 		  "2 4  1  3\n"
 		  "3 5  3  8\n"
 		  "4 5  3  7\n"
 		  "@attributes\n"
 		  "source 0\n"
 		  "sink   5\n";
 		void checkCirculationCompile()
+		{
 		  typedef int VType;
 		  typedef concepts::Digraph Digraph;
 		  typedef Digraph::Node Node;
 		  typedef Digraph::Arc Arc;
 		  typedef concepts::ReadMap<Arc,VType> CapMap;
 		  typedef concepts::ReadMap<Node,VType> SupplyMap;
 		  typedef concepts::ReadWriteMap<Arc,VType> FlowMap;
 		  typedef concepts::WriteMap<Node,bool> BarrierMap;
 		  typedef Elevator<Digraph, Digraph::Node> Elev;
 		  typedef LinkedElevator<Digraph, Digraph::Node> LinkedElev;
 		  Digraph g;
 		  Node n;
 		  Arc a;
 		  CapMap lcap, ucap;
 		  SupplyMap supply;
 		  FlowMap flow;
 		  BarrierMap bar;
 		  VType v;
 		  bool b;
 		  typedef Circulation<Digraph, CapMap, CapMap, SupplyMap>
 		            ::SetFlowMap<FlowMap>
 		            ::SetElevator<Elev>
 		            ::SetStandardElevator<LinkedElev>
 		            ::Create CirculationType;
 		  CirculationType circ_test(g, lcap, ucap, supply);
 		  const CirculationType& const_circ_test = circ_test;
 		  circ_test
 		    .lowerMap(lcap)
 		    .upperMap(ucap)
 		    .supplyMap(supply)
 		    .flowMap(flow);
 		  const CirculationType::Elevator& elev = const_circ_test.elevator();
 		  circ_test.elevator(const_cast<CirculationType::Elevator&>(elev));
 		  CirculationType::Tolerance tol = const_circ_test.tolerance();
 		  circ_test.tolerance(tol);
 		  circ_test.init();
 		  circ_test.greedyInit();
 		  circ_test.start();
 		  circ_test.run();
 		  v = const_circ_test.flow(a);
 		  const FlowMap& fm = const_circ_test.flowMap();
 		  b = const_circ_test.barrier(n);
 		  const_circ_test.barrierMap(bar);
 		  ignore_unused_variable_warning(fm);
+		}
 		template <class G, class LM, class UM, class DM>
 		void checkCirculation(const G& g, const LM& lm, const UM& um,
 		                      const DM& dm, bool find)
+		{
 		  Circulation<G, LM, UM, DM> circ(g, lm, um, dm);
 		  bool ret = circ.run();
 		  if (find) {
 		    check(ret, "A feasible solution should have been found.");
 		    check(circ.checkFlow(), "The found flow is corrupt.");
 		    check(!circ.checkBarrier(), "A barrier should not have been found.");
 		  } else {
 		    check(!ret, "A feasible solution should not have been found.");
 		    check(circ.checkBarrier(), "The found barrier is corrupt.");
+		  }
+		}
 		int main (int, char*[])
+		{
 		  typedef ListDigraph Digraph;
 		  DIGRAPH_TYPEDEFS(Digraph);
 		  Digraph g;
 		  IntArcMap lo(g), up(g);
 		  IntNodeMap delta(g, 0);
 		  Node s, t;
 		  std::istringstream input(test_lgf);
 		  DigraphReader<Digraph>(g,input).
 		    arcMap("lcap", lo).
 		    arcMap("ucap", up).
 		    node("source",s).
 		    node("sink",t).
 		    run();
 		  delta[s] = 7; delta[t] = -7;
 		  checkCirculation(g, lo, up, delta, true);
 		  delta[s] = 13; delta[t] = -13;
 		  checkCirculation(g, lo, up, delta, true);
 		  delta[s] = 6; delta[t] = -6;
 		  checkCirculation(g, lo, up, delta, false);
 		  delta[s] = 14; delta[t] = -14;
 		  checkCirculation(g, lo, up, delta, false);
 		  delta[s] = 7; delta[t] = -13;
 		  checkCirculation(g, lo, up, delta, true);
 		  delta[s] = 5; delta[t] = -15;
 		  checkCirculation(g, lo, up, delta, true);
 		  delta[s] = 10; delta[t] = -11;
 		  checkCirculation(g, lo, up, delta, true);
 		  delta[s] = 11; delta[t] = -10;
 		  checkCirculation(g, lo, up, delta, false);
 		  return 0;
+		}

test/heap_test.cc

Show inline comments

 		/* -*- mode: C++; indent-tabs-mode: nil; -*-
+		 *
 		 * This file is a part of LEMON, a generic C++ optimization library.
+		 *
 		 * 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.
+		 *
 		 */
 		#include <iostream>
 		#include <fstream>
 		#include <string>
 		#include <vector>
 		#include <lemon/concept_check.h>
 		#include <lemon/concepts/heap.h>
 		#include <lemon/smart_graph.h>
 		#include <lemon/lgf_reader.h>
 		#include <lemon/dijkstra.h>
 		#include <lemon/maps.h>
 		#include <lemon/bin_heap.h>
 		#include <lemon/fourary_heap.h>
 		#include <lemon/kary_heap.h>
 		#include <lemon/fib_heap.h>
 		#include <lemon/pairing_heap.h>
 		#include <lemon/radix_heap.h>
 		#include <lemon/binom_heap.h>
 		#include <lemon/bucket_heap.h>
 		#include "test_tools.h"
 		using namespace lemon;
 		using namespace lemon::concepts;
 		typedef ListDigraph Digraph;
 		DIGRAPH_TYPEDEFS(Digraph);
 		char test_lgf[] =
 		  "@nodes\n"
 		  "label\n"
 		  "0\n"
 		  "1\n"
 		  "2\n"
 		  "3\n"
 		  "4\n"
 		  "5\n"
 		  "6\n"
 		  "7\n"
 		  "8\n"
 		  "9\n"
 		  "@arcs\n"
 		  "                label   capacity\n"
 		  "0       5       0       94\n"
 		  "3       9       1       11\n"
 		  "8       7       2       83\n"
 		  "1       2       3       94\n"
 		  "5       7       4       35\n"
 		  "7       4       5       84\n"
 		  "9       5       6       38\n"
 		  "0       4       7       96\n"
 		  "6       7       8       6\n"
 		  "3       1       9       27\n"
 		  "5       2       10      77\n"
 		  "5       6       11      69\n"
 		  "6       5       12      41\n"
 		  "4       6       13      70\n"
 		  "3       2       14      45\n"
 		  "7       9       15      93\n"
 		  "5       9       16      50\n"
 		  "9       0       17      94\n"
 		  "9       6       18      67\n"
 		  "0       9       19      86\n"
 		  "@attributes\n"
 		  "source 3\n";
 		int test_seq[] = { 2, 28, 19, 27, 33, 25, 13, 41, 10, 26,  1,  9,  4, 34};
 		int test_inc[] = {20, 28, 34, 16,  0, 46, 44,  0, 42, 32, 14,  8,  6, 37};
 		int test_len = sizeof(test_seq) / sizeof(test_seq[0]);
 		template <typename Heap>
 		void heapSortTest() {
 		  RangeMap<int> map(test_len, -1);
 		  Heap heap(map);
 		  std::vector<int> v(test_len);
 		  for (int i = 0; i < test_len; ++i) {
 		    v[i] = test_seq[i];
 		    heap.push(i, v[i]);
+		  }
 		  std::sort(v.begin(), v.end());
 		  for (int i = 0; i < test_len; ++i) {
-		    check(v[i] == heap.prio() ,"Wrong order in heap sort.");
+		    check(v[i] == heap.prio(), "Wrong order in heap sort.");
 		    heap.pop();
+		  }
+		}
 		template <typename Heap>
 		void heapIncreaseTest() {
 		  RangeMap<int> map(test_len, -1);
 		  Heap heap(map);
 		  std::vector<int> v(test_len);
 		  for (int i = 0; i < test_len; ++i) {
 		    v[i] = test_seq[i];
 		    heap.push(i, v[i]);
+		  }
 		  for (int i = 0; i < test_len; ++i) {
 		    v[i] += test_inc[i];
 		    heap.increase(i, v[i]);
+		  }
 		  std::sort(v.begin(), v.end());
 		  for (int i = 0; i < test_len; ++i) {
-		    check(v[i] == heap.prio() ,"Wrong order in heap increase test.");
+		    check(v[i] == heap.prio(), "Wrong order in heap increase test.");
 		    heap.pop();
+		  }
+		}
 		template <typename Heap>
 		void dijkstraHeapTest(const Digraph& digraph, const IntArcMap& length,
 		                      Node source) {
 		  typename Dijkstra<Digraph, IntArcMap>::template SetStandardHeap<Heap>::
 		    Create dijkstra(digraph, length);
 		  dijkstra.run(source);
 		  for(ArcIt a(digraph); a != INVALID; ++a) {
 		    Node s = digraph.source(a);
 		    Node t = digraph.target(a);
 		    if (dijkstra.reached(s)) {
 		      check( dijkstra.dist(t) - dijkstra.dist(s) <= length[a],
-		             "Error in a shortest path tree!");
+		             "Error in shortest path tree.");
+		    }
+		  }
 		  for(NodeIt n(digraph); n != INVALID; ++n) {
 		    if ( dijkstra.reached(n) && dijkstra.predArc(n) != INVALID ) {
 		      Arc a = dijkstra.predArc(n);
 		      Node s = digraph.source(a);
 		      check( dijkstra.dist(n) - dijkstra.dist(s) == length[a],
-		             "Error in a shortest path tree!");
+		             "Error in shortest path tree.");
+		    }
+		  }
+		}
 		int main() {
 		  typedef int Item;
 		  typedef int Prio;
 		  typedef RangeMap<int> ItemIntMap;
 		  Digraph digraph;
 		  IntArcMap length(digraph);
 		  Node source;
 		  std::istringstream input(test_lgf);
 		  digraphReader(digraph, input).
 		    arcMap("capacity", length).
 		    node("source", source).
 		    run();
 		  // BinHeap
+		  {
 		    typedef BinHeap<Prio, ItemIntMap> IntHeap;
 		    checkConcept<Heap<Prio, ItemIntMap>, IntHeap>();
 		    heapSortTest<IntHeap>();
 		    heapIncreaseTest<IntHeap>();
 		    typedef BinHeap<Prio, IntNodeMap > NodeHeap;
 		    checkConcept<Heap<Prio, IntNodeMap >, NodeHeap>();
 		    dijkstraHeapTest<NodeHeap>(digraph, length, source);
+		  }
 		  // FouraryHeap
+		  {
 		    typedef FouraryHeap<Prio, ItemIntMap> IntHeap;
 		    checkConcept<Heap<Prio, ItemIntMap>, IntHeap>();
 		    heapSortTest<IntHeap>();
 		    heapIncreaseTest<IntHeap>();
 		    typedef FouraryHeap<Prio, IntNodeMap > NodeHeap;
 		    checkConcept<Heap<Prio, IntNodeMap >, NodeHeap>();
 		    dijkstraHeapTest<NodeHeap>(digraph, length, source);
+		  }
 		  // KaryHeap
+		  {
 		    typedef KaryHeap<Prio, ItemIntMap> IntHeap;
 		    checkConcept<Heap<Prio, ItemIntMap>, IntHeap>();
 		    heapSortTest<IntHeap>();
 		    heapIncreaseTest<IntHeap>();
 		    typedef KaryHeap<Prio, IntNodeMap > NodeHeap;
 		    checkConcept<Heap<Prio, IntNodeMap >, NodeHeap>();
 		    dijkstraHeapTest<NodeHeap>(digraph, length, source);
+		  }
 		  // FibHeap
+		  {
 		    typedef FibHeap<Prio, ItemIntMap> IntHeap;
 		    checkConcept<Heap<Prio, ItemIntMap>, IntHeap>();
 		    heapSortTest<IntHeap>();
 		    heapIncreaseTest<IntHeap>();
 		    typedef FibHeap<Prio, IntNodeMap > NodeHeap;
 		    checkConcept<Heap<Prio, IntNodeMap >, NodeHeap>();
 		    dijkstraHeapTest<NodeHeap>(digraph, length, source);
+		  }
 		  // PairingHeap
+		  {
 		    typedef PairingHeap<Prio, ItemIntMap> IntHeap;
 		    checkConcept<Heap<Prio, ItemIntMap>, IntHeap>();
 		    heapSortTest<IntHeap>();
 		    heapIncreaseTest<IntHeap>();
 		    typedef PairingHeap<Prio, IntNodeMap > NodeHeap;
 		    checkConcept<Heap<Prio, IntNodeMap >, NodeHeap>();
 		    dijkstraHeapTest<NodeHeap>(digraph, length, source);
+		  }
 		  // RadixHeap
+		  {
 		    typedef RadixHeap<ItemIntMap> IntHeap;
 		    checkConcept<Heap<Prio, ItemIntMap>, IntHeap>();
 		    heapSortTest<IntHeap>();
 		    heapIncreaseTest<IntHeap>();
 		    typedef RadixHeap<IntNodeMap > NodeHeap;
 		    checkConcept<Heap<Prio, IntNodeMap >, NodeHeap>();
 		    dijkstraHeapTest<NodeHeap>(digraph, length, source);
+		  }
 		  // BinomHeap
+		  {
 		    typedef BinomHeap<Prio, ItemIntMap> IntHeap;
 		    checkConcept<Heap<Prio, ItemIntMap>, IntHeap>();
 		    heapSortTest<IntHeap>();
 		    heapIncreaseTest<IntHeap>();
 		    typedef BinomHeap<Prio, IntNodeMap > NodeHeap;
 		    checkConcept<Heap<Prio, IntNodeMap >, NodeHeap>();
 		    dijkstraHeapTest<NodeHeap>(digraph, length, source);
+		  }
 		  // BucketHeap, SimpleBucketHeap
+		  {
 		    typedef BucketHeap<ItemIntMap> IntHeap;
 		    checkConcept<Heap<Prio, ItemIntMap>, IntHeap>();
 		    heapSortTest<IntHeap>();
 		    heapIncreaseTest<IntHeap>();
 		    typedef BucketHeap<IntNodeMap > NodeHeap;
 		    checkConcept<Heap<Prio, IntNodeMap >, NodeHeap>();
 		    dijkstraHeapTest<NodeHeap>(digraph, length, source);
 		    typedef SimpleBucketHeap<ItemIntMap> SimpleIntHeap;
 		    heapSortTest<SimpleIntHeap>();
+		  }
 		  return 0;
+		}

test/maps_test.cc

Show inline comments

 		/* -*- mode: C++; indent-tabs-mode: nil; -*-
+		 *
 		 * This file is a part of LEMON, a generic C++ optimization library.
+		 *
 		 * 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.
+		 *
 		 */
 		#include <deque>
 		#include <set>
 		#include <lemon/concept_check.h>
 		#include <lemon/concepts/maps.h>
 		#include <lemon/maps.h>
 		#include <lemon/smart_graph.h>
 		#include "test_tools.h"
 		using namespace lemon;
 		using namespace lemon::concepts;
 		struct A {};
 		inline bool operator<(A, A) { return true; }
 		struct B {};
 		class C {
 		  int x;
 		public:
 		  C(int _x) : x(_x) {}
 		};
 		class F {
 		public:
 		  typedef A argument_type;
 		  typedef B result_type;
 		  B operator()(const A&) const { return B(); }
 		private:
 		  F& operator=(const F&);
 		};
 		int func(A) { return 3; }
 		int binc(int a, B) { return a+1; }
 		typedef ReadMap<A, double> DoubleMap;
 		typedef ReadWriteMap<A, double> DoubleWriteMap;
 		typedef ReferenceMap<A, double, double&, const double&> DoubleRefMap;
 		typedef ReadMap<A, bool> BoolMap;
 		typedef ReadWriteMap<A, bool> BoolWriteMap;
 		typedef ReferenceMap<A, bool, bool&, const bool&> BoolRefMap;
 		int main()
+		{
 		  // Map concepts
 		  checkConcept<ReadMap<A,B>, ReadMap<A,B> >();
 		  checkConcept<ReadMap<A,C>, ReadMap<A,C> >();
 		  checkConcept<WriteMap<A,B>, WriteMap<A,B> >();
 		  checkConcept<WriteMap<A,C>, WriteMap<A,C> >();
 		  checkConcept<ReadWriteMap<A,B>, ReadWriteMap<A,B> >();
 		  checkConcept<ReadWriteMap<A,C>, ReadWriteMap<A,C> >();
 		  checkConcept<ReferenceMap<A,B,B&,const B&>, ReferenceMap<A,B,B&,const B&> >();
 		  checkConcept<ReferenceMap<A,C,C&,const C&>, ReferenceMap<A,C,C&,const C&> >();
 		  // NullMap
+		  {
 		    checkConcept<ReadWriteMap<A,B>, NullMap<A,B> >();
 		    NullMap<A,B> map1;
 		    NullMap<A,B> map2 = map1;
 		    map1 = nullMap<A,B>();
+		  }
 		  // ConstMap
+		  {
 		    checkConcept<ReadWriteMap<A,B>, ConstMap<A,B> >();
 		    checkConcept<ReadWriteMap<A,C>, ConstMap<A,C> >();
 		    ConstMap<A,B> map1;
 		    ConstMap<A,B> map2 = B();
 		    ConstMap<A,B> map3 = map1;
 		    map1 = constMap<A>(B());
 		    map1 = constMap<A,B>();
 		    map1.setAll(B());
 		    ConstMap<A,C> map4(C(1));
 		    ConstMap<A,C> map5 = map4;
 		    map4 = constMap<A>(C(2));
 		    map4.setAll(C(3));
 		    checkConcept<ReadWriteMap<A,int>, ConstMap<A,int> >();
 		    check(constMap<A>(10)[A()] == 10, "Something is wrong with ConstMap");
 		    checkConcept<ReadWriteMap<A,int>, ConstMap<A,Const<int,10> > >();
 		    ConstMap<A,Const<int,10> > map6;
 		    ConstMap<A,Const<int,10> > map7 = map6;
 		    map6 = constMap<A,int,10>();
 		    map7 = constMap<A,Const<int,10> >();
 		    check(map6[A()] == 10 && map7[A()] == 10,
 		          "Something is wrong with ConstMap");
+		  }
 		  // IdentityMap
+		  {
 		    checkConcept<ReadMap<A,A>, IdentityMap<A> >();
 		    IdentityMap<A> map1;
 		    IdentityMap<A> map2 = map1;
 		    map1 = identityMap<A>();
 		    checkConcept<ReadMap<double,double>, IdentityMap<double> >();
 		    check(identityMap<double>()[1.0] == 1.0 &&
 		          identityMap<double>()[3.14] == 3.14,
 		          "Something is wrong with IdentityMap");
+		  }
 		  // RangeMap
+		  {
 		    checkConcept<ReferenceMap<int,B,B&,const B&>, RangeMap<B> >();
 		    RangeMap<B> map1;
 		    RangeMap<B> map2(10);
 		    RangeMap<B> map3(10,B());
 		    RangeMap<B> map4 = map1;
 		    RangeMap<B> map5 = rangeMap<B>();
 		    RangeMap<B> map6 = rangeMap<B>(10);
 		    RangeMap<B> map7 = rangeMap(10,B());
 		    checkConcept< ReferenceMap<int, double, double&, const double&>,
 		                  RangeMap<double> >();
 		    std::vector<double> v(10, 0);
 		    v[5] = 100;
 		    RangeMap<double> map8(v);
 		    RangeMap<double> map9 = rangeMap(v);
 		    check(map9.size() == 10 && map9[2] == 0 && map9[5] == 100,
 		          "Something is wrong with RangeMap");
+		  }
 		  // SparseMap
+		  {
 		    checkConcept<ReferenceMap<A,B,B&,const B&>, SparseMap<A,B> >();
 		    SparseMap<A,B> map1;
 		    SparseMap<A,B> map2 = B();
 		    SparseMap<A,B> map3 = sparseMap<A,B>();
 		    SparseMap<A,B> map4 = sparseMap<A>(B());
 		    checkConcept< ReferenceMap<double, int, int&, const int&>,
 		                  SparseMap<double, int> >();
 		    std::map<double, int> m;
 		    SparseMap<double, int> map5(m);
 		    SparseMap<double, int> map6(m,10);
 		    SparseMap<double, int> map7 = sparseMap(m);
 		    SparseMap<double, int> map8 = sparseMap(m,10);
 		    check(map5[1.0] == 0 && map5[3.14] == 0 &&
 		          map6[1.0] == 10 && map6[3.14] == 10,
 		          "Something is wrong with SparseMap");
 		    map5[1.0] = map6[3.14] = 100;
 		    check(map5[1.0] == 100 && map5[3.14] == 0 &&
 		          map6[1.0] == 10 && map6[3.14] == 100,
 		          "Something is wrong with SparseMap");
+		  }
 		  // ComposeMap
+		  {
 		    typedef ComposeMap<DoubleMap, ReadMap<B,A> > CompMap;
 		    checkConcept<ReadMap<B,double>, CompMap>();
 		    CompMap map1 = CompMap(DoubleMap(),ReadMap<B,A>());
 		    CompMap map2 = composeMap(DoubleMap(), ReadMap<B,A>());
 		    SparseMap<double, bool> m1(false); m1[3.14] = true;
 		    RangeMap<double> m2(2); m2[0] = 3.0; m2[1] = 3.14;
 		    check(!composeMap(m1,m2)[0] && composeMap(m1,m2)[1],
 		          "Something is wrong with ComposeMap")
+		  }
 		  // CombineMap
+		  {
 		    typedef CombineMap<DoubleMap, DoubleMap, std::plus<double> > CombMap;
 		    checkConcept<ReadMap<A,double>, CombMap>();
 		    CombMap map1 = CombMap(DoubleMap(), DoubleMap());
 		    CombMap map2 = combineMap(DoubleMap(), DoubleMap(), std::plus<double>());
 		    check(combineMap(constMap<B,int,2>(), identityMap<B>(), &binc)[B()] == 3,
 		          "Something is wrong with CombineMap");
+		  }
 		  // FunctorToMap, MapToFunctor
+		  {
 		    checkConcept<ReadMap<A,B>, FunctorToMap<F,A,B> >();
 		    checkConcept<ReadMap<A,B>, FunctorToMap<F> >();
 		    FunctorToMap<F> map1;
 		    FunctorToMap<F> map2 = FunctorToMap<F>(F());
 		    B b = functorToMap(F())[A()];
 		    checkConcept<ReadMap<A,B>, MapToFunctor<ReadMap<A,B> > >();
 		    MapToFunctor<ReadMap<A,B> > map = MapToFunctor<ReadMap<A,B> >(ReadMap<A,B>());
 		    check(functorToMap(&func)[A()] == 3,
 		          "Something is wrong with FunctorToMap");
 		    check(mapToFunctor(constMap<A,int>(2))(A()) == 2,
 		          "Something is wrong with MapToFunctor");
 		    check(mapToFunctor(functorToMap(&func))(A()) == 3 &&
 		          mapToFunctor(functorToMap(&func))[A()] == 3,
 		          "Something is wrong with FunctorToMap or MapToFunctor");
 		    check(functorToMap(mapToFunctor(constMap<A,int>(2)))[A()] == 2,
 		          "Something is wrong with FunctorToMap or MapToFunctor");
+		  }
 		  // ConvertMap
+		  {
 		    checkConcept<ReadMap<double,double>,
 		      ConvertMap<ReadMap<double, int>, double> >();
 		    ConvertMap<RangeMap<bool>, int> map1(rangeMap(1, true));
 		    ConvertMap<RangeMap<bool>, int> map2 = convertMap<int>(rangeMap(2, false));
+		  }
 		  // ForkMap
+		  {
 		    checkConcept<DoubleWriteMap, ForkMap<DoubleWriteMap, DoubleWriteMap> >();
 		    typedef RangeMap<double> RM;
 		    typedef SparseMap<int, double> SM;
 		    RM m1(10, -1);
 		    SM m2(-1);
 		    checkConcept<ReadWriteMap<int, double>, ForkMap<RM, SM> >();
 		    checkConcept<ReadWriteMap<int, double>, ForkMap<SM, RM> >();
 		    ForkMap<RM, SM> map1(m1,m2);
 		    ForkMap<SM, RM> map2 = forkMap(m2,m1);
 		    map2.set(5, 10);
 		    check(m1[1] == -1 && m1[5] == 10 && m2[1] == -1 &&
 		          m2[5] == 10 && map2[1] == -1 && map2[5] == 10,
 		          "Something is wrong with ForkMap");
+		  }
 		  // Arithmetic maps:
 		  // - AddMap, SubMap, MulMap, DivMap
 		  // - ShiftMap, ShiftWriteMap, ScaleMap, ScaleWriteMap
 		  // - NegMap, NegWriteMap, AbsMap
+		  {
 		    checkConcept<DoubleMap, AddMap<DoubleMap,DoubleMap> >();
 		    checkConcept<DoubleMap, SubMap<DoubleMap,DoubleMap> >();
 		    checkConcept<DoubleMap, MulMap<DoubleMap,DoubleMap> >();
 		    checkConcept<DoubleMap, DivMap<DoubleMap,DoubleMap> >();
 		    ConstMap<int, double> c1(1.0), c2(3.14);
 		    IdentityMap<int> im;
 		    ConvertMap<IdentityMap<int>, double> id(im);
 		    check(addMap(c1,id)[0] == 1.0  && addMap(c1,id)[10] == 11.0,
 		          "Something is wrong with AddMap");
 		    check(subMap(id,c1)[0] == -1.0 && subMap(id,c1)[10] == 9.0,
 		          "Something is wrong with SubMap");
 		    check(mulMap(id,c2)[0] == 0    && mulMap(id,c2)[2]  == 6.28,
 		          "Something is wrong with MulMap");
 		    check(divMap(c2,id)[1] == 3.14 && divMap(c2,id)[2]  == 1.57,
 		          "Something is wrong with DivMap");
 		    checkConcept<DoubleMap, ShiftMap<DoubleMap> >();
 		    checkConcept<DoubleWriteMap, ShiftWriteMap<DoubleWriteMap> >();
 		    checkConcept<DoubleMap, ScaleMap<DoubleMap> >();
 		    checkConcept<DoubleWriteMap, ScaleWriteMap<DoubleWriteMap> >();
 		    checkConcept<DoubleMap, NegMap<DoubleMap> >();
 		    checkConcept<DoubleWriteMap, NegWriteMap<DoubleWriteMap> >();
 		    checkConcept<DoubleMap, AbsMap<DoubleMap> >();
 		    check(shiftMap(id, 2.0)[1] == 3.0 && shiftMap(id, 2.0)[10] == 12.0,
 		          "Something is wrong with ShiftMap");
 		    check(shiftWriteMap(id, 2.0)[1] == 3.0 &&
 		          shiftWriteMap(id, 2.0)[10] == 12.0,
 		          "Something is wrong with ShiftWriteMap");
 		    check(scaleMap(id, 2.0)[1] == 2.0 && scaleMap(id, 2.0)[10] == 20.0,
 		          "Something is wrong with ScaleMap");
 		    check(scaleWriteMap(id, 2.0)[1] == 2.0 &&
 		          scaleWriteMap(id, 2.0)[10] == 20.0,
 		          "Something is wrong with ScaleWriteMap");
 		    check(negMap(id)[1] == -1.0 && negMap(id)[-10] == 10.0,
 		          "Something is wrong with NegMap");
 		    check(negWriteMap(id)[1] == -1.0 && negWriteMap(id)[-10] == 10.0,
 		          "Something is wrong with NegWriteMap");
 		    check(absMap(id)[1] == 1.0 && absMap(id)[-10] == 10.0,
 		          "Something is wrong with AbsMap");
+		  }
 		  // Logical maps:
 		  // - TrueMap, FalseMap
 		  // - AndMap, OrMap
 		  // - NotMap, NotWriteMap
 		  // - EqualMap, LessMap
+		  {
 		    checkConcept<BoolMap, TrueMap<A> >();
 		    checkConcept<BoolMap, FalseMap<A> >();
 		    checkConcept<BoolMap, AndMap<BoolMap,BoolMap> >();
 		    checkConcept<BoolMap, OrMap<BoolMap,BoolMap> >();
 		    checkConcept<BoolMap, NotMap<BoolMap> >();
 		    checkConcept<BoolWriteMap, NotWriteMap<BoolWriteMap> >();
 		    checkConcept<BoolMap, EqualMap<DoubleMap,DoubleMap> >();
 		    checkConcept<BoolMap, LessMap<DoubleMap,DoubleMap> >();
 		    TrueMap<int> tm;
 		    FalseMap<int> fm;
 		    RangeMap<bool> rm(2);
 		    rm[0] = true; rm[1] = false;
 		    check(andMap(tm,rm)[0] && !andMap(tm,rm)[1] &&
 		          !andMap(fm,rm)[0] && !andMap(fm,rm)[1],
 		          "Something is wrong with AndMap");
 		    check(orMap(tm,rm)[0] && orMap(tm,rm)[1] &&
 		          orMap(fm,rm)[0] && !orMap(fm,rm)[1],
 		          "Something is wrong with OrMap");
 		    check(!notMap(rm)[0] && notMap(rm)[1],
 		          "Something is wrong with NotMap");
 		    check(!notWriteMap(rm)[0] && notWriteMap(rm)[1],
 		          "Something is wrong with NotWriteMap");
 		    ConstMap<int, double> cm(2.0);
 		    IdentityMap<int> im;
 		    ConvertMap<IdentityMap<int>, double> id(im);
 		    check(lessMap(id,cm)[1] && !lessMap(id,cm)[2] && !lessMap(id,cm)[3],
 		          "Something is wrong with LessMap");
 		    check(!equalMap(id,cm)[1] && equalMap(id,cm)[2] && !equalMap(id,cm)[3],
 		          "Something is wrong with EqualMap");
+		  }
 		  // LoggerBoolMap
+		  {
 		    typedef std::vector<int> vec;
 		    vec v1;
 		    vec v2(10);
 		    LoggerBoolMap<std::back_insert_iterator<vec> >
 		      map1(std::back_inserter(v1));
 		    LoggerBoolMap<vec::iterator> map2(v2.begin());
 		    map1.set(10, false);
 		    map1.set(20, true);   map2.set(20, true);
 		    map1.set(30, false);  map2.set(40, false);
 		    map1.set(50, true);   map2.set(50, true);
 		    map1.set(60, true);   map2.set(60, true);
 		    check(v1.size() == 3 && v2.size() == 10 &&
 		          v1[0]==20 && v1[1]==50 && v1[2]==60 &&
 		          v2[0]==20 && v2[1]==50 && v2[2]==60,
 		          "Something is wrong with LoggerBoolMap");
 		    int i = 0;
 		    for ( LoggerBoolMap<vec::iterator>::Iterator it = map2.begin();
 		          it != map2.end(); ++it )
 		      check(v1[i++] == *it, "Something is wrong with LoggerBoolMap");
+		  }
 		  // CrossRefMap
+		  {
 		    typedef SmartDigraph Graph;
 		    DIGRAPH_TYPEDEFS(Graph);
 		    checkConcept<ReadWriteMap<Node, int>,
 		                 CrossRefMap<Graph, Node, int> >();
 		    Graph gr;
 		    typedef CrossRefMap<Graph, Node, char> CRMap;
 		    typedef CRMap::ValueIterator ValueIt;
 		    CRMap map(gr);
 		    Node n0 = gr.addNode();
 		    Node n1 = gr.addNode();
 		    Node n2 = gr.addNode();
 		    map.set(n0, 'A');
 		    map.set(n1, 'B');
 		    map.set(n2, 'C');
 		    map.set(n2, 'A');
 		    map.set(n0, 'C');
 		    check(map[n0] == 'C' && map[n1] == 'B' && map[n2] == 'A',
 		          "Wrong CrossRefMap");
 		    check(map('A') == n2 && map.inverse()['A'] == n2, "Wrong CrossRefMap");
 		    check(map('B') == n1 && map.inverse()['B'] == n1, "Wrong CrossRefMap");
 		    check(map('C') == n0 && map.inverse()['C'] == n0, "Wrong CrossRefMap");
 		    ValueIt it = map.beginValue();
 		    check(*it++ == 'A' && *it++ == 'B' && *it++ == 'C' &&
 		          it == map.endValue(), "Wrong value iterator");
+		  }
 		  // Iterable bool map
+		  {
 		    typedef SmartGraph Graph;
 		    typedef SmartGraph::Node Item;
 		    typedef IterableBoolMap<SmartGraph, SmartGraph::Node> Ibm;
 		    checkConcept<ReferenceMap<Item, bool, bool&, const bool&>, Ibm>();
 		    const int num = 10;
 		    Graph g;
 		    std::vector<Item> items;
 		    for (int i = 0; i < num; ++i) {
 		      items.push_back(g.addNode());
+		    }
 		    Ibm map1(g, true);
 		    int n = 0;
 		    for (Ibm::TrueIt it(map1); it != INVALID; ++it) {
 		      check(map1[static_cast<Item>(it)], "Wrong TrueIt");
 		      ++n;
+		    }
 		    check(n == num, "Wrong number");
 		    n = 0;
 		    for (Ibm::ItemIt it(map1, true); it != INVALID; ++it) {
 		        check(map1[static_cast<Item>(it)], "Wrong ItemIt for true");
 		        ++n;
+		    }
 		    check(n == num, "Wrong number");
 		    check(Ibm::FalseIt(map1) == INVALID, "Wrong FalseIt");
 		    check(Ibm::ItemIt(map1, false) == INVALID, "Wrong ItemIt for false");
 		    map1[items[5]] = true;
 		    n = 0;
 		    for (Ibm::ItemIt it(map1, true); it != INVALID; ++it) {
 		        check(map1[static_cast<Item>(it)], "Wrong ItemIt for true");
 		        ++n;
+		    }
 		    check(n == num, "Wrong number");
 		    map1[items[num / 2]] = false;
 		    check(map1[items[num / 2]] == false, "Wrong map value");
 		    n = 0;
 		    for (Ibm::TrueIt it(map1); it != INVALID; ++it) {
 		        check(map1[static_cast<Item>(it)], "Wrong TrueIt for true");
 		        ++n;
+		    }
 		    check(n == num - 1, "Wrong number");
 		    n = 0;
 		    for (Ibm::FalseIt it(map1); it != INVALID; ++it) {
 		        check(!map1[static_cast<Item>(it)], "Wrong FalseIt for true");
 		        ++n;
+		    }
 		    check(n == 1, "Wrong number");
 		    map1[items[0]] = false;
 		    check(map1[items[0]] == false, "Wrong map value");
 		    map1[items[num - 1]] = false;
 		    check(map1[items[num - 1]] == false, "Wrong map value");
 		    n = 0;
 		    for (Ibm::TrueIt it(map1); it != INVALID; ++it) {
 		        check(map1[static_cast<Item>(it)], "Wrong TrueIt for true");
 		        ++n;
+		    }
 		    check(n == num - 3, "Wrong number");
 		    check(map1.trueNum() == num - 3, "Wrong number");
 		    n = 0;
 		    for (Ibm::FalseIt it(map1); it != INVALID; ++it) {
 		        check(!map1[static_cast<Item>(it)], "Wrong FalseIt for true");
 		        ++n;
+		    }
 		    check(n == 3, "Wrong number");
 		    check(map1.falseNum() == 3, "Wrong number");
+		  }
 		  // Iterable int map
+		  {
 		    typedef SmartGraph Graph;
 		    typedef SmartGraph::Node Item;
 		    typedef IterableIntMap<SmartGraph, SmartGraph::Node> Iim;
 		    checkConcept<ReferenceMap<Item, int, int&, const int&>, Iim>();
 		    const int num = 10;
 		    Graph g;
 		    std::vector<Item> items;
 		    for (int i = 0; i < num; ++i) {
 		      items.push_back(g.addNode());
+		    }
 		    Iim map1(g);
 		    check(map1.size() == 0, "Wrong size");
 		    for (int i = 0; i < num; ++i) {
 		      map1[items[i]] = i;
+		    }
 		    check(map1.size() == num, "Wrong size");
 		    for (int i = 0; i < num; ++i) {
 		      Iim::ItemIt it(map1, i);
 		      check(static_cast<Item>(it) == items[i], "Wrong value");
 		      ++it;
 		      check(static_cast<Item>(it) == INVALID, "Wrong value");
+		    }
 		    for (int i = 0; i < num; ++i) {
 		      map1[items[i]] = i % 2;
+		    }
 		    check(map1.size() == 2, "Wrong size");
 		    int n = 0;
 		    for (Iim::ItemIt it(map1, 0); it != INVALID; ++it) {
 		      check(map1[static_cast<Item>(it)] == 0, "Wrong value");
 		      ++n;
+		    }
 		    check(n == (num + 1) / 2, "Wrong number");
 		    for (Iim::ItemIt it(map1, 1); it != INVALID; ++it) {
 		      check(map1[static_cast<Item>(it)] == 1, "Wrong value");
 		      ++n;
+		    }
 		    check(n == num, "Wrong number");
+		  }
 		  // Iterable value map
+		  {
 		    typedef SmartGraph Graph;
 		    typedef SmartGraph::Node Item;
 		    typedef IterableValueMap<SmartGraph, SmartGraph::Node, double> Ivm;
 		    checkConcept<ReadWriteMap<Item, double>, Ivm>();
 		    const int num = 10;
 		    Graph g;
 		    std::vector<Item> items;
 		    for (int i = 0; i < num; ++i) {
 		      items.push_back(g.addNode());
+		    }
 		    Ivm map1(g, 0.0);
 		    check(distance(map1.beginValue(), map1.endValue()) == 1, "Wrong size");
 		    check(*map1.beginValue() == 0.0, "Wrong value");
 		    for (int i = 0; i < num; ++i) {
 		      map1.set(items[i], static_cast<double>(i));
+		    }
 		    check(distance(map1.beginValue(), map1.endValue()) == num, "Wrong size");
 		    for (int i = 0; i < num; ++i) {
 		      Ivm::ItemIt it(map1, static_cast<double>(i));
 		      check(static_cast<Item>(it) == items[i], "Wrong value");
 		      ++it;
 		      check(static_cast<Item>(it) == INVALID, "Wrong value");
+		    }
 		    for (Ivm::ValueIterator vit = map1.beginValue();
 		         vit != map1.endValue(); ++vit) {
 		      check(map1[static_cast<Item>(Ivm::ItemIt(map1, *vit))] == *vit,
 		            "Wrong ValueIterator");
+		    }
 		    for (int i = 0; i < num; ++i) {
 		      map1.set(items[i], static_cast<double>(i % 2));
+		    }
 		    check(distance(map1.beginValue(), map1.endValue()) == 2, "Wrong size");
 		    int n = 0;
 		    for (Ivm::ItemIt it(map1, 0.0); it != INVALID; ++it) {
 		      check(map1[static_cast<Item>(it)] == 0.0, "Wrong value");
 		      ++n;
+		    }
 		    check(n == (num + 1) / 2, "Wrong number");
 		    for (Ivm::ItemIt it(map1, 1.0); it != INVALID; ++it) {
 		      check(map1[static_cast<Item>(it)] == 1.0, "Wrong value");
 		      ++n;
+		    }
 		    check(n == num, "Wrong number");
+		  }
 		  return 0;
+		}

test/preflow_test.cc

Show inline comments

 		/* -*- mode: C++; indent-tabs-mode: nil; -*-
+		 *
 		 * This file is a part of LEMON, a generic C++ optimization library.
+		 *
 		 * 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.
+		 *
 		 */
 		#include <iostream>
 		#include "test_tools.h"
 		#include <lemon/smart_graph.h>
 		#include <lemon/preflow.h>
 		#include <lemon/concepts/digraph.h>
 		#include <lemon/concepts/maps.h>
 		#include <lemon/lgf_reader.h>
 		#include <lemon/elevator.h>
 		using namespace lemon;
 		char test_lgf[] =
 		  "@nodes\n"
 		  "label\n"
 		  "0\n"
 		  "1\n"
 		  "2\n"
 		  "3\n"
 		  "4\n"
 		  "5\n"
 		  "6\n"
 		  "7\n"
 		  "8\n"
 		  "9\n"
 		  "@arcs\n"
 		  "    label capacity\n"
 		  "0 1 0     20\n"
 		  "0 2 1     0\n"
 		  "1 1 2     3\n"
 		  "1 2 3     8\n"
 		  "1 3 4     8\n"
 		  "2 5 5     5\n"
 		  "3 2 6     5\n"
 		  "3 5 7     5\n"
 		  "3 6 8     5\n"
 		  "4 3 9     3\n"
 		  "5 7 10    3\n"
 		  "5 6 11    10\n"
 		  "5 8 12    10\n"
 		  "6 8 13    8\n"
 		  "8 9 14    20\n"
 		  "8 1 15    5\n"
 		  "9 5 16    5\n"
 		  "@attributes\n"
 		  "source 1\n"
 		  "target 8\n";
 		void checkPreflowCompile()
+		{
 		  typedef int VType;
 		  typedef concepts::Digraph Digraph;
 		  typedef Digraph::Node Node;
 		  typedef Digraph::Arc Arc;
 		  typedef concepts::ReadMap<Arc,VType> CapMap;
 		  typedef concepts::ReadWriteMap<Arc,VType> FlowMap;
 		  typedef concepts::WriteMap<Node,bool> CutMap;
 		  typedef Elevator<Digraph, Digraph::Node> Elev;
 		  typedef LinkedElevator<Digraph, Digraph::Node> LinkedElev;
 		  Digraph g;
 		  Node n;
 		  Arc e;
 		  CapMap cap;
 		  FlowMap flow;
 		  CutMap cut;
 		  VType v;
 		  bool b;
 		  typedef Preflow<Digraph, CapMap>
 		            ::SetFlowMap<FlowMap>
 		            ::SetElevator<Elev>
 		            ::SetStandardElevator<LinkedElev>
 		            ::Create PreflowType;
 		  PreflowType preflow_test(g, cap, n, n);
 		  const PreflowType& const_preflow_test = preflow_test;
 		  const PreflowType::Elevator& elev = const_preflow_test.elevator();
 		  preflow_test.elevator(const_cast<PreflowType::Elevator&>(elev));
 		  PreflowType::Tolerance tol = const_preflow_test.tolerance();
 		  preflow_test.tolerance(tol);
 		  preflow_test
 		    .capacityMap(cap)
 		    .flowMap(flow)
 		    .source(n)
 		    .target(n);
 		  preflow_test.init();
 		  preflow_test.init(cap);
 		  preflow_test.startFirstPhase();
 		  preflow_test.startSecondPhase();
 		  preflow_test.run();
 		  preflow_test.runMinCut();
 		  v = const_preflow_test.flowValue();
 		  v = const_preflow_test.flow(e);
 		  const FlowMap& fm = const_preflow_test.flowMap();
 		  b = const_preflow_test.minCut(n);
 		  const_preflow_test.minCutMap(cut);
 		  ignore_unused_variable_warning(fm);
+		}
 		int cutValue (const SmartDigraph& g,
 		              const SmartDigraph::NodeMap<bool>& cut,
 		              const SmartDigraph::ArcMap<int>& cap) {
 		  int c=0;
 		  for(SmartDigraph::ArcIt e(g); e!=INVALID; ++e) {
 		    if (cut[g.source(e)] && !cut[g.target(e)]) c+=cap[e];
+		  }
 		  return c;
+		}
 		bool checkFlow(const SmartDigraph& g,
 		               const SmartDigraph::ArcMap<int>& flow,
 		               const SmartDigraph::ArcMap<int>& cap,
 		               SmartDigraph::Node s, SmartDigraph::Node t) {
 		  for (SmartDigraph::ArcIt e(g); e != INVALID; ++e) {
 		    if (flow[e] < 0 || flow[e] > cap[e]) return false;
+		  }
 		  for (SmartDigraph::NodeIt n(g); n != INVALID; ++n) {
 		    if (n == s || n == t) continue;
 		    int sum = 0;
 		    for (SmartDigraph::OutArcIt e(g, n); e != INVALID; ++e) {
 		      sum += flow[e];
+		    }
 		    for (SmartDigraph::InArcIt e(g, n); e != INVALID; ++e) {
 		      sum -= flow[e];
+		    }
 		    if (sum != 0) return false;
+		  }
 		  return true;
+		}
 		int main() {
 		  typedef SmartDigraph Digraph;
 		  typedef Digraph::Node Node;
 		  typedef Digraph::NodeIt NodeIt;
 		  typedef Digraph::ArcIt ArcIt;
 		  typedef Digraph::ArcMap<int> CapMap;
 		  typedef Digraph::ArcMap<int> FlowMap;
 		  typedef Digraph::NodeMap<bool> CutMap;
 		  typedef Preflow<Digraph, CapMap> PType;
 		  Digraph g;
 		  Node s, t;
 		  CapMap cap(g);
 		  std::istringstream input(test_lgf);
 		  DigraphReader<Digraph>(g,input).
 		    arcMap("capacity", cap).
 		    node("source",s).
 		    node("target",t).
 		    run();
 		  PType preflow_test(g, cap, s, t);
 		  preflow_test.run();
 		  check(checkFlow(g, preflow_test.flowMap(), cap, s, t),
 		        "The flow is not feasible.");
 		  CutMap min_cut(g);
 		  preflow_test.minCutMap(min_cut);
 		  int min_cut_value=cutValue(g,min_cut,cap);
 		  check(preflow_test.flowValue() == min_cut_value,
 		        "The max flow value is not equal to the three min cut values.");
 		  FlowMap flow(g);
 		  for(ArcIt e(g); e!=INVALID; ++e) flow[e] = preflow_test.flowMap()[e];
 		  int flow_value=preflow_test.flowValue();
 		  for(ArcIt e(g); e!=INVALID; ++e) cap[e]=2*cap[e];
 		  preflow_test.init(flow);
 		  preflow_test.startFirstPhase();
 		  CutMap min_cut1(g);
 		  preflow_test.minCutMap(min_cut1);
 		  min_cut_value=cutValue(g,min_cut1,cap);
 		  check(preflow_test.flowValue() == min_cut_value &&
 		        min_cut_value == 2*flow_value,
 		        "The max flow value or the min cut value is wrong.");
 		  preflow_test.startSecondPhase();
 		  check(checkFlow(g, preflow_test.flowMap(), cap, s, t),
 		        "The flow is not feasible.");
 		  CutMap min_cut2(g);
 		  preflow_test.minCutMap(min_cut2);
 		  min_cut_value=cutValue(g,min_cut2,cap);
 		  check(preflow_test.flowValue() == min_cut_value &&
 		        min_cut_value == 2*flow_value,
 		        "The max flow value or the three min cut values were not doubled");
 		  preflow_test.flowMap(flow);
 		  NodeIt tmp1(g,s);
 		  ++tmp1;
 		  if ( tmp1 != INVALID ) s=tmp1;
 		  NodeIt tmp2(g,t);
 		  ++tmp2;
 		  if ( tmp2 != INVALID ) t=tmp2;
 		  preflow_test.source(s);
 		  preflow_test.target(t);
 		  preflow_test.run();
 		  CutMap min_cut3(g);
 		  preflow_test.minCutMap(min_cut3);
 		  min_cut_value=cutValue(g,min_cut3,cap);
 		  check(preflow_test.flowValue() == min_cut_value,
 		        "The max flow value or the three min cut values are incorrect.");
 		  return 0;
+		}

tools/lemon-0.x-to-1.x.sh

Show inline comments

 		#!/bin/bash
 		set -e
 		if [ $# -eq 0 -o x$1 = "x-h" -o x$1 = "x-help" -o x$1 = "x--help" ]; then
 		    echo "Usage:"
 		    echo "  $0 source-file(s)"
 		    exit
 		fi
 		for i in $@
 		do
 		    echo Update $i...
 		    TMP=`mktemp`
 		    sed -e "s/\<undirected graph\>/_gr_aph_label_/g"\
 		        -e "s/\<undirected graphs\>/_gr_aph_label_s/g"\
 		        -e "s/\<undirected edge\>/_ed_ge_label_/g"\
 		        -e "s/\<undirected edges\>/_ed_ge_label_s/g"\
 		        -e "s/\<directed graph\>/_digr_aph_label_/g"\
 		        -e "s/\<directed graphs\>/_digr_aph_label_s/g"\
 		        -e "s/\<directed edge\>/_ar_c_label_/g"\
 		        -e "s/\<directed edges\>/_ar_c_label_s/g"\
 		        -e "s/UGraph/_Gr_aph_label_/g"\
 		        -e "s/u[Gg]raph/_gr_aph_label_/g"\
 		        -e "s/Graph\>/_Digr_aph_label_/g"\
 		        -e "s/\<graph\>/_digr_aph_label_/g"\
 		        -e "s/Graphs\>/_Digr_aph_label_s/g"\
 		        -e "s/\<graphs\>/_digr_aph_label_s/g"\
 		        -e "s/\([Gg]\)raph\([a-z]\)/_\1r_aph_label_\2/g"\
 		        -e "s/\([a-z_]\)graph/\1_gr_aph_label_/g"\
 		        -e "s/Graph/_Digr_aph_label_/g"\
 		        -e "s/graph/_digr_aph_label_/g"\
 		        -e "s/UEdge/_Ed_ge_label_/g"\
 		        -e "s/u[Ee]dge/_ed_ge_label_/g"\
 		        -e "s/IncEdgeIt/_In_cEd_geIt_label_/g"\
 		        -e "s/Edge\>/_Ar_c_label_/g"\
 		        -e "s/\<edge\>/_ar_c_label_/g"\
-		        -e "s/_edge\>/_ar_c_label_/g"\
+		        -e "s/_edge\>/__ar_c_label_/g"\
 		        -e "s/Edges\>/_Ar_c_label_s/g"\
 		        -e "s/\<edges\>/_ar_c_label_s/g"\
-		        -e "s/_edges\>/_ar_c_label_s/g"\
+		        -e "s/_edges\>/__ar_c_label_s/g"\
 		        -e "s/\([Ee]\)dge\([a-z]\)/_\1d_ge_label_\2/g"\
 		        -e "s/\([a-z]\)edge/\1_ed_ge_label_/g"\
 		        -e "s/Edge/_Ar_c_label_/g"\
 		        -e "s/edge/_ar_c_label_/g"\
 		        -e "s/A[Nn]ode/_Re_d_label_/g"\
 		        -e "s/B[Nn]ode/_Blu_e_label_/g"\
 		        -e "s/A-[Nn]ode/_Re_d_label_/g"\
 		        -e "s/B-[Nn]ode/_Blu_e_label_/g"\
 		        -e "s/a[Nn]ode/_re_d_label_/g"\
 		        -e "s/b[Nn]ode/_blu_e_label_/g"\
 		        -e "s/\<UGRAPH_TYPEDEFS\([ \t]*([ \t]*\)typename[ \t]/TEMPLATE__GR_APH_TY_PEDE_FS_label_\1/g"\
 		        -e "s/\<GRAPH_TYPEDEFS\([ \t]*([ \t]*\)typename[ \t]/TEMPLATE__DIGR_APH_TY_PEDE_FS_label_\1/g"\
 		        -e "s/\<UGRAPH_TYPEDEFS\>/_GR_APH_TY_PEDE_FS_label_/g"\
 		        -e "s/\<GRAPH_TYPEDEFS\>/_DIGR_APH_TY_PEDE_FS_label_/g"\
 		        -e "s/_Digr_aph_label_/Digraph/g"\
 		        -e "s/_digr_aph_label_/digraph/g"\
 		        -e "s/_Gr_aph_label_/Graph/g"\
 		        -e "s/_gr_aph_label_/graph/g"\
 		        -e "s/_Ar_c_label_/Arc/g"\
 		        -e "s/_ar_c_label_/arc/g"\
 		        -e "s/_Ed_ge_label_/Edge/g"\
 		        -e "s/_ed_ge_label_/edge/g"\
 		        -e "s/_In_cEd_geIt_label_/IncEdgeIt/g"\
 		        -e "s/_Re_d_label_/Red/g"\
 		        -e "s/_Blu_e_label_/Blue/g"\
 		        -e "s/_re_d_label_/red/g"\
 		        -e "s/_blu_e_label_/blue/g"\
 		        -e "s/_GR_APH_TY_PEDE_FS_label_/GRAPH_TYPEDEFS/g"\
 		        -e "s/_DIGR_APH_TY_PEDE_FS_label_/DIGRAPH_TYPEDEFS/g"\
 		        -e "s/\<digraph_adaptor\.h\>/adaptors.h/g"\
 		        -e "s/\<digraph_utils\.h\>/core.h/g"\
 		        -e "s/\<digraph_reader\.h\>/lgf_reader.h/g"\
 		        -e "s/\<digraph_writer\.h\>/lgf_writer.h/g"\
 		        -e "s/\<topology\.h\>/connectivity.h/g"\
 		        -e "s/DigraphToEps/GraphToEps/g"\
 		        -e "s/digraphToEps/graphToEps/g"\
 		        -e "s/\<DefPredMap\>/SetPredMap/g"\
 		        -e "s/\<DefDistMap\>/SetDistMap/g"\
 		        -e "s/\<DefReachedMap\>/SetReachedMap/g"\
 		        -e "s/\<DefProcessedMap\>/SetProcessedMap/g"\
 		        -e "s/\<DefHeap\>/SetHeap/g"\
 		        -e "s/\<DefStandardHeap\>/SetStandradHeap/g"\
 		        -e "s/\<DefOperationTraits\>/SetOperationTraits/g"\
 		        -e "s/\<DefProcessedMapToBeDefaultMap\>/SetStandardProcessedMap/g"\
 		        -e "s/\<copyGraph\>/graphCopy/g"\
 		        -e "s/\<copyDigraph\>/digraphCopy/g"\
 		        -e "s/\<HyperCubeDigraph\>/HypercubeGraph/g"\
 		        -e "s/\<IntegerMap\>/RangeMap/g"\
 		        -e "s/\<integerMap\>/rangeMap/g"\
 		        -e "s/\<\([sS]\)tdMap\>/\1parseMap/g"\
 		        -e "s/\<\([Ff]\)unctorMap\>/\1unctorToMap/g"\
 		        -e "s/\<\([Mm]\)apFunctor\>/\1apToFunctor/g"\
 		        -e "s/\<\([Ff]\)orkWriteMap\>/\1orkMap/g"\
 		        -e "s/\<StoreBoolMap\>/LoggerBoolMap/g"\
 		        -e "s/\<storeBoolMap\>/loggerBoolMap/g"\
 		        -e "s/\<InvertableMap\>/CrossRefMap/g"\
 		        -e "s/\<invertableMap\>/crossRefMap/g"\
 		        -e "s/\<DescriptorMap\>/RangeIdMap/g"\
 		        -e "s/\<descriptorMap\>/rangeIdMap/g"\
 		        -e "s/\<BoundingBox\>/Box/g"\
 		        -e "s/\<readNauty\>/readNautyGraph/g"\
 		        -e "s/\<RevDigraphAdaptor\>/ReverseDigraph/g"\
 		        -e "s/\<revDigraphAdaptor\>/reverseDigraph/g"\
 		        -e "s/\<SubDigraphAdaptor\>/SubDigraph/g"\
 		        -e "s/\<subDigraphAdaptor\>/subDigraph/g"\
 		        -e "s/\<SubGraphAdaptor\>/SubGraph/g"\
 		        -e "s/\<subGraphAdaptor\>/subGraph/g"\
 		        -e "s/\<NodeSubDigraphAdaptor\>/FilterNodes/g"\
 		        -e "s/\<nodeSubDigraphAdaptor\>/filterNodes/g"\
 		        -e "s/\<ArcSubDigraphAdaptor\>/FilterArcs/g"\
 		        -e "s/\<arcSubDigraphAdaptor\>/filterArcs/g"\
 		        -e "s/\<UndirDigraphAdaptor\>/Undirector/g"\
 		        -e "s/\<undirDigraphAdaptor\>/undirector/g"\
 		        -e "s/\<ResDigraphAdaptor\>/ResidualDigraph/g"\
 		        -e "s/\<resDigraphAdaptor\>/residualDigraph/g"\
 		        -e "s/\<SplitDigraphAdaptor\>/SplitNodes/g"\
 		        -e "s/\<splitDigraphAdaptor\>/splitNodes/g"\
 		        -e "s/\<SubGraphAdaptor\>/SubGraph/g"\
 		        -e "s/\<subGraphAdaptor\>/subGraph/g"\
 		        -e "s/\<NodeSubGraphAdaptor\>/FilterNodes/g"\
 		        -e "s/\<nodeSubGraphAdaptor\>/filterNodes/g"\
 		        -e "s/\<ArcSubGraphAdaptor\>/FilterEdges/g"\
 		        -e "s/\<arcSubGraphAdaptor\>/filterEdges/g"\
 		        -e "s/\<DirGraphAdaptor\>/Orienter/g"\
 		        -e "s/\<dirGraphAdaptor\>/orienter/g"\
 		        -e "s/\<LpCplex\>/CplexLp/g"\
 		        -e "s/\<MipCplex\>/CplexMip/g"\
 		        -e "s/\<LpGlpk\>/GlpkLp/g"\
 		        -e "s/\<MipGlpk\>/GlpkMip/g"\
 		        -e "s/\<LpSoplex\>/SoplexLp/g"\
 		    <$i > $TMP
 		    mv $TMP $i
 		done

0 comments (0 inline)

RhodeCode

Login to your account