Bfs/Dfs/Dijkstra and their deps ported from svn trung -r 3441.
authorAlpar Juttner <alpar@cs.elte.hu>
Thu, 07 Feb 2008 21:37:07 +0000
changeset 1004f754b4cf82b
parent 99 dbaa96cc1013
child 101 70f3967ca6eb
Bfs/Dfs/Dijkstra and their deps ported from svn trung -r 3441.
lemon/Makefile.am
lemon/bfs.h
lemon/bin_heap.h
lemon/bits/path_dump.h
lemon/concepts/heap.h
lemon/dfs.h
lemon/dijkstra.h
lemon/graph_utils.h
lemon/path.h
test/Makefile.am
test/bfs_test.cc
test/dfs_test.cc
test/heap_test.cc
test/heap_test.h
test/test_tools.h
     1.1 --- a/lemon/Makefile.am	Thu Feb 07 21:28:39 2008 +0000
     1.2 +++ b/lemon/Makefile.am	Thu Feb 07 21:37:07 2008 +0000
     1.3 @@ -15,9 +15,13 @@
     1.4  lemon_libemon_la_LDFLAGS = $(GLPK_LIBS) $(CPLEX_LIBS) $(SOPLEX_LIBS)
     1.5  
     1.6  lemon_HEADERS += \
     1.7 -        lemon/concept_check.h \
     1.8 +        lemon/bfs.h \
     1.9 +        lemon/bin_heap.h \
    1.10 +        lemon/dfs.h \
    1.11 +        lemon/dijkstra.h \
    1.12          lemon/dim2.h \
    1.13  	lemon/error.h \
    1.14 +        lemon/graph_utils.h \
    1.15  	lemon/list_graph.h \
    1.16  	lemon/maps.h \
    1.17  	lemon/path.h \
    1.18 @@ -32,6 +36,7 @@
    1.19  	lemon/bits/graph_extender.h \
    1.20          lemon/bits/invalid.h \
    1.21  	lemon/bits/map_extender.h \
    1.22 +	lemon/bits/path_dump.h \
    1.23  	lemon/bits/traits.h \
    1.24          lemon/bits/utility.h \
    1.25  	lemon/bits/vector_map.h
    1.26 @@ -40,6 +45,7 @@
    1.27  	lemon/concept_check.h \
    1.28  	lemon/concepts/digraph.h \
    1.29  	lemon/concepts/graph.h \
    1.30 +	lemon/concepts/heap.h \
    1.31  	lemon/concepts/maps.h \
    1.32  	lemon/concepts/path.h \
    1.33  	lemon/concepts/graph_components.h
     2.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
     2.2 +++ b/lemon/bfs.h	Thu Feb 07 21:37:07 2008 +0000
     2.3 @@ -0,0 +1,1597 @@
     2.4 +/* -*- C++ -*-
     2.5 + *
     2.6 + * This file is a part of LEMON, a generic C++ optimization library
     2.7 + *
     2.8 + * Copyright (C) 2003-2008
     2.9 + * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
    2.10 + * (Egervary Research Group on Combinatorial Optimization, EGRES).
    2.11 + *
    2.12 + * Permission to use, modify and distribute this software is granted
    2.13 + * provided that this copyright notice appears in all copies. For
    2.14 + * precise terms see the accompanying LICENSE file.
    2.15 + *
    2.16 + * This software is provided "AS IS" with no warranty of any kind,
    2.17 + * express or implied, and with no claim as to its suitability for any
    2.18 + * purpose.
    2.19 + *
    2.20 + */
    2.21 +
    2.22 +#ifndef LEMON_BFS_H
    2.23 +#define LEMON_BFS_H
    2.24 +
    2.25 +///\ingroup search
    2.26 +///\file
    2.27 +///\brief Bfs algorithm.
    2.28 +
    2.29 +#include <lemon/list_graph.h>
    2.30 +#include <lemon/graph_utils.h>
    2.31 +#include <lemon/bits/path_dump.h>
    2.32 +#include <lemon/bits/invalid.h>
    2.33 +#include <lemon/error.h>
    2.34 +#include <lemon/maps.h>
    2.35 +
    2.36 +namespace lemon {
    2.37 +
    2.38 +
    2.39 +  
    2.40 +  ///Default traits class of Bfs class.
    2.41 +
    2.42 +  ///Default traits class of Bfs class.
    2.43 +  ///\param GR Digraph type.
    2.44 +  template<class GR>
    2.45 +  struct BfsDefaultTraits
    2.46 +  {
    2.47 +    ///The digraph type the algorithm runs on. 
    2.48 +    typedef GR Digraph;
    2.49 +    ///\brief The type of the map that stores the last
    2.50 +    ///arcs of the shortest paths.
    2.51 +    /// 
    2.52 +    ///The type of the map that stores the last
    2.53 +    ///arcs of the shortest paths.
    2.54 +    ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
    2.55 +    ///
    2.56 +    typedef typename Digraph::template NodeMap<typename GR::Arc> PredMap;
    2.57 +    ///Instantiates a PredMap.
    2.58 + 
    2.59 +    ///This function instantiates a \ref PredMap. 
    2.60 +    ///\param G is the digraph, to which we would like to define the PredMap.
    2.61 +    ///\todo The digraph alone may be insufficient to initialize
    2.62 +    static PredMap *createPredMap(const GR &G) 
    2.63 +    {
    2.64 +      return new PredMap(G);
    2.65 +    }
    2.66 +    ///The type of the map that indicates which nodes are processed.
    2.67 + 
    2.68 +    ///The type of the map that indicates which nodes are processed.
    2.69 +    ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
    2.70 +    ///\todo named parameter to set this type, function to read and write.
    2.71 +    typedef NullMap<typename Digraph::Node,bool> ProcessedMap;
    2.72 +    ///Instantiates a ProcessedMap.
    2.73 + 
    2.74 +    ///This function instantiates a \ref ProcessedMap. 
    2.75 +    ///\param g is the digraph, to which
    2.76 +    ///we would like to define the \ref ProcessedMap
    2.77 +#ifdef DOXYGEN
    2.78 +    static ProcessedMap *createProcessedMap(const GR &g)
    2.79 +#else
    2.80 +    static ProcessedMap *createProcessedMap(const GR &)
    2.81 +#endif
    2.82 +    {
    2.83 +      return new ProcessedMap();
    2.84 +    }
    2.85 +    ///The type of the map that indicates which nodes are reached.
    2.86 + 
    2.87 +    ///The type of the map that indicates which nodes are reached.
    2.88 +    ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
    2.89 +    ///\todo named parameter to set this type, function to read and write.
    2.90 +    typedef typename Digraph::template NodeMap<bool> ReachedMap;
    2.91 +    ///Instantiates a ReachedMap.
    2.92 + 
    2.93 +    ///This function instantiates a \ref ReachedMap. 
    2.94 +    ///\param G is the digraph, to which
    2.95 +    ///we would like to define the \ref ReachedMap.
    2.96 +    static ReachedMap *createReachedMap(const GR &G)
    2.97 +    {
    2.98 +      return new ReachedMap(G);
    2.99 +    }
   2.100 +    ///The type of the map that stores the dists of the nodes.
   2.101 + 
   2.102 +    ///The type of the map that stores the dists of the nodes.
   2.103 +    ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
   2.104 +    ///
   2.105 +    typedef typename Digraph::template NodeMap<int> DistMap;
   2.106 +    ///Instantiates a DistMap.
   2.107 + 
   2.108 +    ///This function instantiates a \ref DistMap. 
   2.109 +    ///\param G is the digraph, to which we would like to define the \ref DistMap
   2.110 +    static DistMap *createDistMap(const GR &G)
   2.111 +    {
   2.112 +      return new DistMap(G);
   2.113 +    }
   2.114 +  };
   2.115 +  
   2.116 +  ///%BFS algorithm class.
   2.117 +  
   2.118 +  ///\ingroup search
   2.119 +  ///This class provides an efficient implementation of the %BFS algorithm.
   2.120 +  ///
   2.121 +  ///\param GR The digraph type the algorithm runs on. The default value is
   2.122 +  ///\ref ListDigraph. The value of GR is not used directly by Bfs, it
   2.123 +  ///is only passed to \ref BfsDefaultTraits.
   2.124 +  ///\param TR Traits class to set various data types used by the algorithm.
   2.125 +  ///The default traits class is
   2.126 +  ///\ref BfsDefaultTraits "BfsDefaultTraits<GR>".
   2.127 +  ///See \ref BfsDefaultTraits for the documentation of
   2.128 +  ///a Bfs traits class.
   2.129 +  ///
   2.130 +  ///\author Alpar Juttner
   2.131 +
   2.132 +#ifdef DOXYGEN
   2.133 +  template <typename GR,
   2.134 +	    typename TR>
   2.135 +#else
   2.136 +  template <typename GR=ListDigraph,
   2.137 +	    typename TR=BfsDefaultTraits<GR> >
   2.138 +#endif
   2.139 +  class Bfs {
   2.140 +  public:
   2.141 +    /**
   2.142 +     * \brief \ref Exception for uninitialized parameters.
   2.143 +     *
   2.144 +     * This error represents problems in the initialization
   2.145 +     * of the parameters of the algorithms.
   2.146 +     */
   2.147 +    class UninitializedParameter : public lemon::UninitializedParameter {
   2.148 +    public:
   2.149 +      virtual const char* what() const throw() {
   2.150 +	return "lemon::Bfs::UninitializedParameter";
   2.151 +      }
   2.152 +    };
   2.153 +
   2.154 +    typedef TR Traits;
   2.155 +    ///The type of the underlying digraph.
   2.156 +    typedef typename TR::Digraph Digraph;
   2.157 +    
   2.158 +    ///\brief The type of the map that stores the last
   2.159 +    ///arcs of the shortest paths.
   2.160 +    typedef typename TR::PredMap PredMap;
   2.161 +    ///The type of the map indicating which nodes are reached.
   2.162 +    typedef typename TR::ReachedMap ReachedMap;
   2.163 +    ///The type of the map indicating which nodes are processed.
   2.164 +    typedef typename TR::ProcessedMap ProcessedMap;
   2.165 +    ///The type of the map that stores the dists of the nodes.
   2.166 +    typedef typename TR::DistMap DistMap;
   2.167 +  private:
   2.168 +
   2.169 +    typedef typename Digraph::Node Node;
   2.170 +    typedef typename Digraph::NodeIt NodeIt;
   2.171 +    typedef typename Digraph::Arc Arc;
   2.172 +    typedef typename Digraph::OutArcIt OutArcIt;
   2.173 +
   2.174 +    /// Pointer to the underlying digraph.
   2.175 +    const Digraph *G;
   2.176 +    ///Pointer to the map of predecessors arcs.
   2.177 +    PredMap *_pred;
   2.178 +    ///Indicates if \ref _pred is locally allocated (\c true) or not.
   2.179 +    bool local_pred;
   2.180 +    ///Pointer to the map of distances.
   2.181 +    DistMap *_dist;
   2.182 +    ///Indicates if \ref _dist is locally allocated (\c true) or not.
   2.183 +    bool local_dist;
   2.184 +    ///Pointer to the map of reached status of the nodes.
   2.185 +    ReachedMap *_reached;
   2.186 +    ///Indicates if \ref _reached is locally allocated (\c true) or not.
   2.187 +    bool local_reached;
   2.188 +    ///Pointer to the map of processed status of the nodes.
   2.189 +    ProcessedMap *_processed;
   2.190 +    ///Indicates if \ref _processed is locally allocated (\c true) or not.
   2.191 +    bool local_processed;
   2.192 +
   2.193 +    std::vector<typename Digraph::Node> _queue;
   2.194 +    int _queue_head,_queue_tail,_queue_next_dist;
   2.195 +    int _curr_dist;
   2.196 +
   2.197 +    ///Creates the maps if necessary.
   2.198 +    
   2.199 +    ///\todo Better memory allocation (instead of new).
   2.200 +    void create_maps() 
   2.201 +    {
   2.202 +      if(!_pred) {
   2.203 +	local_pred = true;
   2.204 +	_pred = Traits::createPredMap(*G);
   2.205 +      }
   2.206 +      if(!_dist) {
   2.207 +	local_dist = true;
   2.208 +	_dist = Traits::createDistMap(*G);
   2.209 +      }
   2.210 +      if(!_reached) {
   2.211 +	local_reached = true;
   2.212 +	_reached = Traits::createReachedMap(*G);
   2.213 +      }
   2.214 +      if(!_processed) {
   2.215 +	local_processed = true;
   2.216 +	_processed = Traits::createProcessedMap(*G);
   2.217 +      }
   2.218 +    }
   2.219 +
   2.220 +  protected:
   2.221 +    
   2.222 +    Bfs() {}
   2.223 +    
   2.224 +  public:
   2.225 + 
   2.226 +    typedef Bfs Create;
   2.227 +
   2.228 +    ///\name Named template parameters
   2.229 +
   2.230 +    ///@{
   2.231 +
   2.232 +    template <class T>
   2.233 +    struct DefPredMapTraits : public Traits {
   2.234 +      typedef T PredMap;
   2.235 +      static PredMap *createPredMap(const Digraph &) 
   2.236 +      {
   2.237 +	throw UninitializedParameter();
   2.238 +      }
   2.239 +    };
   2.240 +    ///\brief \ref named-templ-param "Named parameter" for setting
   2.241 +    ///PredMap type
   2.242 +    ///
   2.243 +    ///\ref named-templ-param "Named parameter" for setting PredMap type
   2.244 +    ///
   2.245 +    template <class T>
   2.246 +    struct DefPredMap : public Bfs< Digraph, DefPredMapTraits<T> > { 
   2.247 +      typedef Bfs< Digraph, DefPredMapTraits<T> > Create;
   2.248 +    };
   2.249 +    
   2.250 +    template <class T>
   2.251 +    struct DefDistMapTraits : public Traits {
   2.252 +      typedef T DistMap;
   2.253 +      static DistMap *createDistMap(const Digraph &) 
   2.254 +      {
   2.255 +	throw UninitializedParameter();
   2.256 +      }
   2.257 +    };
   2.258 +    ///\brief \ref named-templ-param "Named parameter" for setting
   2.259 +    ///DistMap type
   2.260 +    ///
   2.261 +    ///\ref named-templ-param "Named parameter" for setting DistMap type
   2.262 +    ///
   2.263 +    template <class T>
   2.264 +    struct DefDistMap : public Bfs< Digraph, DefDistMapTraits<T> > { 
   2.265 +      typedef Bfs< Digraph, DefDistMapTraits<T> > Create;
   2.266 +    };
   2.267 +    
   2.268 +    template <class T>
   2.269 +    struct DefReachedMapTraits : public Traits {
   2.270 +      typedef T ReachedMap;
   2.271 +      static ReachedMap *createReachedMap(const Digraph &) 
   2.272 +      {
   2.273 +	throw UninitializedParameter();
   2.274 +      }
   2.275 +    };
   2.276 +    ///\brief \ref named-templ-param "Named parameter" for setting
   2.277 +    ///ReachedMap type
   2.278 +    ///
   2.279 +    ///\ref named-templ-param "Named parameter" for setting ReachedMap type
   2.280 +    ///
   2.281 +    template <class T>
   2.282 +    struct DefReachedMap : public Bfs< Digraph, DefReachedMapTraits<T> > { 
   2.283 +      typedef Bfs< Digraph, DefReachedMapTraits<T> > Create;
   2.284 +    };
   2.285 +    
   2.286 +    template <class T>
   2.287 +    struct DefProcessedMapTraits : public Traits {
   2.288 +      typedef T ProcessedMap;
   2.289 +      static ProcessedMap *createProcessedMap(const Digraph &) 
   2.290 +      {
   2.291 +	throw UninitializedParameter();
   2.292 +      }
   2.293 +    };
   2.294 +    ///\brief \ref named-templ-param "Named parameter" for setting
   2.295 +    ///ProcessedMap type
   2.296 +    ///
   2.297 +    ///\ref named-templ-param "Named parameter" for setting ProcessedMap type
   2.298 +    ///
   2.299 +    template <class T>
   2.300 +    struct DefProcessedMap : public Bfs< Digraph, DefProcessedMapTraits<T> > {
   2.301 +      typedef Bfs< Digraph, DefProcessedMapTraits<T> > Create;
   2.302 +    };
   2.303 +    
   2.304 +    struct DefDigraphProcessedMapTraits : public Traits {
   2.305 +      typedef typename Digraph::template NodeMap<bool> ProcessedMap;
   2.306 +      static ProcessedMap *createProcessedMap(const Digraph &G) 
   2.307 +      {
   2.308 +	return new ProcessedMap(G);
   2.309 +      }
   2.310 +    };
   2.311 +    ///\brief \ref named-templ-param "Named parameter"
   2.312 +    ///for setting the ProcessedMap type to be Digraph::NodeMap<bool>.
   2.313 +    ///
   2.314 +    ///\ref named-templ-param "Named parameter"
   2.315 +    ///for setting the ProcessedMap type to be Digraph::NodeMap<bool>.
   2.316 +    ///If you don't set it explicitly, it will be automatically allocated.
   2.317 +    template <class T>
   2.318 +    struct DefProcessedMapToBeDefaultMap :
   2.319 +      public Bfs< Digraph, DefDigraphProcessedMapTraits> { 
   2.320 +      typedef Bfs< Digraph, DefDigraphProcessedMapTraits> Create;
   2.321 +    };
   2.322 +    
   2.323 +    ///@}
   2.324 +
   2.325 +  public:      
   2.326 +    
   2.327 +    ///Constructor.
   2.328 +    
   2.329 +    ///\param _G the digraph the algorithm will run on.
   2.330 +    ///
   2.331 +    Bfs(const Digraph& _G) :
   2.332 +      G(&_G),
   2.333 +      _pred(NULL), local_pred(false),
   2.334 +      _dist(NULL), local_dist(false),
   2.335 +      _reached(NULL), local_reached(false),
   2.336 +      _processed(NULL), local_processed(false)
   2.337 +    { }
   2.338 +    
   2.339 +    ///Destructor.
   2.340 +    ~Bfs() 
   2.341 +    {
   2.342 +      if(local_pred) delete _pred;
   2.343 +      if(local_dist) delete _dist;
   2.344 +      if(local_reached) delete _reached;
   2.345 +      if(local_processed) delete _processed;
   2.346 +    }
   2.347 +
   2.348 +    ///Sets the map storing the predecessor arcs.
   2.349 +
   2.350 +    ///Sets the map storing the predecessor arcs.
   2.351 +    ///If you don't use this function before calling \ref run(),
   2.352 +    ///it will allocate one. The destructor deallocates this
   2.353 +    ///automatically allocated map, of course.
   2.354 +    ///\return <tt> (*this) </tt>
   2.355 +    Bfs &predMap(PredMap &m) 
   2.356 +    {
   2.357 +      if(local_pred) {
   2.358 +	delete _pred;
   2.359 +	local_pred=false;
   2.360 +      }
   2.361 +      _pred = &m;
   2.362 +      return *this;
   2.363 +    }
   2.364 +
   2.365 +    ///Sets the map indicating the reached nodes.
   2.366 +
   2.367 +    ///Sets the map indicating the reached nodes.
   2.368 +    ///If you don't use this function before calling \ref run(),
   2.369 +    ///it will allocate one. The destructor deallocates this
   2.370 +    ///automatically allocated map, of course.
   2.371 +    ///\return <tt> (*this) </tt>
   2.372 +    Bfs &reachedMap(ReachedMap &m) 
   2.373 +    {
   2.374 +      if(local_reached) {
   2.375 +	delete _reached;
   2.376 +	local_reached=false;
   2.377 +      }
   2.378 +      _reached = &m;
   2.379 +      return *this;
   2.380 +    }
   2.381 +
   2.382 +    ///Sets the map indicating the processed nodes.
   2.383 +
   2.384 +    ///Sets the map indicating the processed nodes.
   2.385 +    ///If you don't use this function before calling \ref run(),
   2.386 +    ///it will allocate one. The destructor deallocates this
   2.387 +    ///automatically allocated map, of course.
   2.388 +    ///\return <tt> (*this) </tt>
   2.389 +    Bfs &processedMap(ProcessedMap &m) 
   2.390 +    {
   2.391 +      if(local_processed) {
   2.392 +	delete _processed;
   2.393 +	local_processed=false;
   2.394 +      }
   2.395 +      _processed = &m;
   2.396 +      return *this;
   2.397 +    }
   2.398 +
   2.399 +    ///Sets the map storing the distances calculated by the algorithm.
   2.400 +
   2.401 +    ///Sets the map storing the distances calculated by the algorithm.
   2.402 +    ///If you don't use this function before calling \ref run(),
   2.403 +    ///it will allocate one. The destructor deallocates this
   2.404 +    ///automatically allocated map, of course.
   2.405 +    ///\return <tt> (*this) </tt>
   2.406 +    Bfs &distMap(DistMap &m) 
   2.407 +    {
   2.408 +      if(local_dist) {
   2.409 +	delete _dist;
   2.410 +	local_dist=false;
   2.411 +      }
   2.412 +      _dist = &m;
   2.413 +      return *this;
   2.414 +    }
   2.415 +
   2.416 +  public:
   2.417 +    ///\name Execution control
   2.418 +    ///The simplest way to execute the algorithm is to use
   2.419 +    ///one of the member functions called \c run(...).
   2.420 +    ///\n
   2.421 +    ///If you need more control on the execution,
   2.422 +    ///first you must call \ref init(), then you can add several source nodes
   2.423 +    ///with \ref addSource().
   2.424 +    ///Finally \ref start() will perform the actual path
   2.425 +    ///computation.
   2.426 +
   2.427 +    ///@{
   2.428 +
   2.429 +    ///\brief Initializes the internal data structures.
   2.430 +    ///
   2.431 +    ///Initializes the internal data structures.
   2.432 +    ///
   2.433 +    void init()
   2.434 +    {
   2.435 +      create_maps();
   2.436 +      _queue.resize(countNodes(*G));
   2.437 +      _queue_head=_queue_tail=0;
   2.438 +      _curr_dist=1;
   2.439 +      for ( NodeIt u(*G) ; u!=INVALID ; ++u ) {
   2.440 +	_pred->set(u,INVALID);
   2.441 +	_reached->set(u,false);
   2.442 +	_processed->set(u,false);
   2.443 +      }
   2.444 +    }
   2.445 +    
   2.446 +    ///Adds a new source node.
   2.447 +
   2.448 +    ///Adds a new source node to the set of nodes to be processed.
   2.449 +    ///
   2.450 +    void addSource(Node s)
   2.451 +    {
   2.452 +      if(!(*_reached)[s])
   2.453 +	{
   2.454 +	  _reached->set(s,true);
   2.455 +	  _pred->set(s,INVALID);
   2.456 +	  _dist->set(s,0);
   2.457 +	  _queue[_queue_head++]=s;
   2.458 +	  _queue_next_dist=_queue_head;
   2.459 +	}
   2.460 +    }
   2.461 +    
   2.462 +    ///Processes the next node.
   2.463 +
   2.464 +    ///Processes the next node.
   2.465 +    ///
   2.466 +    ///\return The processed node.
   2.467 +    ///
   2.468 +    ///\warning The queue must not be empty!
   2.469 +    Node processNextNode()
   2.470 +    {
   2.471 +      if(_queue_tail==_queue_next_dist) {
   2.472 +	_curr_dist++;
   2.473 +	_queue_next_dist=_queue_head;
   2.474 +      }
   2.475 +      Node n=_queue[_queue_tail++];
   2.476 +      _processed->set(n,true);
   2.477 +      Node m;
   2.478 +      for(OutArcIt e(*G,n);e!=INVALID;++e)
   2.479 +	if(!(*_reached)[m=G->target(e)]) {
   2.480 +	  _queue[_queue_head++]=m;
   2.481 +	  _reached->set(m,true);
   2.482 +	  _pred->set(m,e);
   2.483 +	  _dist->set(m,_curr_dist);
   2.484 +	}
   2.485 +      return n;
   2.486 +    }
   2.487 +
   2.488 +    ///Processes the next node.
   2.489 +
   2.490 +    ///Processes the next node. And checks that the given target node
   2.491 +    ///is reached. If the target node is reachable from the processed
   2.492 +    ///node then the reached parameter will be set true. The reached
   2.493 +    ///parameter should be initially false.
   2.494 +    ///
   2.495 +    ///\param target The target node.
   2.496 +    ///\retval reach Indicates that the target node is reached.
   2.497 +    ///\return The processed node.
   2.498 +    ///
   2.499 +    ///\warning The queue must not be empty!
   2.500 +    Node processNextNode(Node target, bool& reach)
   2.501 +    {
   2.502 +      if(_queue_tail==_queue_next_dist) {
   2.503 +	_curr_dist++;
   2.504 +	_queue_next_dist=_queue_head;
   2.505 +      }
   2.506 +      Node n=_queue[_queue_tail++];
   2.507 +      _processed->set(n,true);
   2.508 +      Node m;
   2.509 +      for(OutArcIt e(*G,n);e!=INVALID;++e)
   2.510 +	if(!(*_reached)[m=G->target(e)]) {
   2.511 +	  _queue[_queue_head++]=m;
   2.512 +	  _reached->set(m,true);
   2.513 +	  _pred->set(m,e);
   2.514 +	  _dist->set(m,_curr_dist);
   2.515 +          reach = reach || (target == m);
   2.516 +	}
   2.517 +      return n;
   2.518 +    }
   2.519 +
   2.520 +    ///Processes the next node.
   2.521 +
   2.522 +    ///Processes the next node. And checks that at least one of
   2.523 +    ///reached node has true value in the \c nm node map. If one node
   2.524 +    ///with true value is reachable from the processed node then the
   2.525 +    ///rnode parameter will be set to the first of such nodes.
   2.526 +    ///
   2.527 +    ///\param nm The node map of possible targets.
   2.528 +    ///\retval rnode The reached target node.
   2.529 +    ///\return The processed node.
   2.530 +    ///
   2.531 +    ///\warning The queue must not be empty!
   2.532 +    template<class NM>
   2.533 +    Node processNextNode(const NM& nm, Node& rnode)
   2.534 +    {
   2.535 +      if(_queue_tail==_queue_next_dist) {
   2.536 +	_curr_dist++;
   2.537 +	_queue_next_dist=_queue_head;
   2.538 +      }
   2.539 +      Node n=_queue[_queue_tail++];
   2.540 +      _processed->set(n,true);
   2.541 +      Node m;
   2.542 +      for(OutArcIt e(*G,n);e!=INVALID;++e)
   2.543 +	if(!(*_reached)[m=G->target(e)]) {
   2.544 +	  _queue[_queue_head++]=m;
   2.545 +	  _reached->set(m,true);
   2.546 +	  _pred->set(m,e);
   2.547 +	  _dist->set(m,_curr_dist);
   2.548 +	  if (nm[m] && rnode == INVALID) rnode = m;
   2.549 +	}
   2.550 +      return n;
   2.551 +    }
   2.552 +      
   2.553 +    ///Next node to be processed.
   2.554 +
   2.555 +    ///Next node to be processed.
   2.556 +    ///
   2.557 +    ///\return The next node to be processed or INVALID if the queue is
   2.558 +    /// empty.
   2.559 +    Node nextNode()
   2.560 +    { 
   2.561 +      return _queue_tail<_queue_head?_queue[_queue_tail]:INVALID;
   2.562 +    }
   2.563 + 
   2.564 +    ///\brief Returns \c false if there are nodes
   2.565 +    ///to be processed in the queue
   2.566 +    ///
   2.567 +    ///Returns \c false if there are nodes
   2.568 +    ///to be processed in the queue
   2.569 +    bool emptyQueue() { return _queue_tail==_queue_head; }
   2.570 +    ///Returns the number of the nodes to be processed.
   2.571 +    
   2.572 +    ///Returns the number of the nodes to be processed in the queue.
   2.573 +    int queueSize() { return _queue_head-_queue_tail; }
   2.574 +    
   2.575 +    ///Executes the algorithm.
   2.576 +
   2.577 +    ///Executes the algorithm.
   2.578 +    ///
   2.579 +    ///\pre init() must be called and at least one node should be added
   2.580 +    ///with addSource() before using this function.
   2.581 +    ///
   2.582 +    ///This method runs the %BFS algorithm from the root node(s)
   2.583 +    ///in order to
   2.584 +    ///compute the
   2.585 +    ///shortest path to each node. The algorithm computes
   2.586 +    ///- The shortest path tree.
   2.587 +    ///- The distance of each node from the root(s).
   2.588 +    void start()
   2.589 +    {
   2.590 +      while ( !emptyQueue() ) processNextNode();
   2.591 +    }
   2.592 +    
   2.593 +    ///Executes the algorithm until \c dest is reached.
   2.594 +
   2.595 +    ///Executes the algorithm until \c dest is reached.
   2.596 +    ///
   2.597 +    ///\pre init() must be called and at least one node should be added
   2.598 +    ///with addSource() before using this function.
   2.599 +    ///
   2.600 +    ///This method runs the %BFS algorithm from the root node(s)
   2.601 +    ///in order to compute the shortest path to \c dest.
   2.602 +    ///The algorithm computes
   2.603 +    ///- The shortest path to \c  dest.
   2.604 +    ///- The distance of \c dest from the root(s).
   2.605 +    void start(Node dest)
   2.606 +    {
   2.607 +      bool reach = false;
   2.608 +      while ( !emptyQueue() && !reach ) processNextNode(dest, reach);
   2.609 +    }
   2.610 +    
   2.611 +    ///Executes the algorithm until a condition is met.
   2.612 +
   2.613 +    ///Executes the algorithm until a condition is met.
   2.614 +    ///
   2.615 +    ///\pre init() must be called and at least one node should be added
   2.616 +    ///with addSource() before using this function.
   2.617 +    ///
   2.618 +    ///\param nm must be a bool (or convertible) node map. The
   2.619 +    ///algorithm will stop when it reaches a node \c v with
   2.620 +    /// <tt>nm[v]</tt> true.
   2.621 +    ///
   2.622 +    ///\return The reached node \c v with <tt>nm[v]</tt> true or
   2.623 +    ///\c INVALID if no such node was found.
   2.624 +    template<class NM>
   2.625 +    Node start(const NM &nm)
   2.626 +    {
   2.627 +      Node rnode = INVALID;
   2.628 +      while ( !emptyQueue() && rnode == INVALID ) {
   2.629 +	processNextNode(nm, rnode);
   2.630 +      }
   2.631 +      return rnode;
   2.632 +    }
   2.633 +    
   2.634 +    ///Runs %BFS algorithm from node \c s.
   2.635 +    
   2.636 +    ///This method runs the %BFS algorithm from a root node \c s
   2.637 +    ///in order to
   2.638 +    ///compute the
   2.639 +    ///shortest path to each node. The algorithm computes
   2.640 +    ///- The shortest path tree.
   2.641 +    ///- The distance of each node from the root.
   2.642 +    ///
   2.643 +    ///\note b.run(s) is just a shortcut of the following code.
   2.644 +    ///\code
   2.645 +    ///  b.init();
   2.646 +    ///  b.addSource(s);
   2.647 +    ///  b.start();
   2.648 +    ///\endcode
   2.649 +    void run(Node s) {
   2.650 +      init();
   2.651 +      addSource(s);
   2.652 +      start();
   2.653 +    }
   2.654 +    
   2.655 +    ///Finds the shortest path between \c s and \c t.
   2.656 +    
   2.657 +    ///Finds the shortest path between \c s and \c t.
   2.658 +    ///
   2.659 +    ///\return The length of the shortest s---t path if there exists one,
   2.660 +    ///0 otherwise.
   2.661 +    ///\note Apart from the return value, b.run(s) is
   2.662 +    ///just a shortcut of the following code.
   2.663 +    ///\code
   2.664 +    ///  b.init();
   2.665 +    ///  b.addSource(s);
   2.666 +    ///  b.start(t);
   2.667 +    ///\endcode
   2.668 +    int run(Node s,Node t) {
   2.669 +      init();
   2.670 +      addSource(s);
   2.671 +      start(t);
   2.672 +      return reached(t) ? _curr_dist : 0;
   2.673 +    }
   2.674 +    
   2.675 +    ///@}
   2.676 +
   2.677 +    ///\name Query Functions
   2.678 +    ///The result of the %BFS algorithm can be obtained using these
   2.679 +    ///functions.\n
   2.680 +    ///Before the use of these functions,
   2.681 +    ///either run() or start() must be calleb.
   2.682 +    
   2.683 +    ///@{
   2.684 +
   2.685 +    typedef PredMapPath<Digraph, PredMap> Path;
   2.686 +
   2.687 +    ///Gives back the shortest path.
   2.688 +    
   2.689 +    ///Gives back the shortest path.
   2.690 +    ///\pre The \c t should be reachable from the source.
   2.691 +    Path path(Node t) 
   2.692 +    {
   2.693 +      return Path(*G, *_pred, t);
   2.694 +    }
   2.695 +
   2.696 +    ///The distance of a node from the root(s).
   2.697 +
   2.698 +    ///Returns the distance of a node from the root(s).
   2.699 +    ///\pre \ref run() must be called before using this function.
   2.700 +    ///\warning If node \c v in unreachable from the root(s) the return value
   2.701 +    ///of this function is undefined.
   2.702 +    int dist(Node v) const { return (*_dist)[v]; }
   2.703 +
   2.704 +    ///Returns the 'previous arc' of the shortest path tree.
   2.705 +
   2.706 +    ///For a node \c v it returns the 'previous arc'
   2.707 +    ///of the shortest path tree,
   2.708 +    ///i.e. it returns the last arc of a shortest path from the root(s) to \c
   2.709 +    ///v. It is \ref INVALID
   2.710 +    ///if \c v is unreachable from the root(s) or \c v is a root. The
   2.711 +    ///shortest path tree used here is equal to the shortest path tree used in
   2.712 +    ///\ref predNode().
   2.713 +    ///\pre Either \ref run() or \ref start() must be called before using
   2.714 +    ///this function.
   2.715 +    Arc predArc(Node v) const { return (*_pred)[v];}
   2.716 +
   2.717 +    ///Returns the 'previous node' of the shortest path tree.
   2.718 +
   2.719 +    ///For a node \c v it returns the 'previous node'
   2.720 +    ///of the shortest path tree,
   2.721 +    ///i.e. it returns the last but one node from a shortest path from the
   2.722 +    ///root(a) to \c /v.
   2.723 +    ///It is INVALID if \c v is unreachable from the root(s) or
   2.724 +    ///if \c v itself a root.
   2.725 +    ///The shortest path tree used here is equal to the shortest path
   2.726 +    ///tree used in \ref predArc().
   2.727 +    ///\pre Either \ref run() or \ref start() must be called before
   2.728 +    ///using this function.
   2.729 +    Node predNode(Node v) const { return (*_pred)[v]==INVALID ? INVALID:
   2.730 +				  G->source((*_pred)[v]); }
   2.731 +    
   2.732 +    ///Returns a reference to the NodeMap of distances.
   2.733 +
   2.734 +    ///Returns a reference to the NodeMap of distances.
   2.735 +    ///\pre Either \ref run() or \ref init() must
   2.736 +    ///be called before using this function.
   2.737 +    const DistMap &distMap() const { return *_dist;}
   2.738 + 
   2.739 +    ///Returns a reference to the shortest path tree map.
   2.740 +
   2.741 +    ///Returns a reference to the NodeMap of the arcs of the
   2.742 +    ///shortest path tree.
   2.743 +    ///\pre Either \ref run() or \ref init()
   2.744 +    ///must be called before using this function.
   2.745 +    const PredMap &predMap() const { return *_pred;}
   2.746 + 
   2.747 +    ///Checks if a node is reachable from the root.
   2.748 +
   2.749 +    ///Returns \c true if \c v is reachable from the root.
   2.750 +    ///\warning The source nodes are indicated as unreached.
   2.751 +    ///\pre Either \ref run() or \ref start()
   2.752 +    ///must be called before using this function.
   2.753 +    ///
   2.754 +    bool reached(Node v) { return (*_reached)[v]; }
   2.755 +    
   2.756 +    ///@}
   2.757 +  };
   2.758 +
   2.759 +  ///Default traits class of Bfs function.
   2.760 +
   2.761 +  ///Default traits class of Bfs function.
   2.762 +  ///\param GR Digraph type.
   2.763 +  template<class GR>
   2.764 +  struct BfsWizardDefaultTraits
   2.765 +  {
   2.766 +    ///The digraph type the algorithm runs on. 
   2.767 +    typedef GR Digraph;
   2.768 +    ///\brief The type of the map that stores the last
   2.769 +    ///arcs of the shortest paths.
   2.770 +    /// 
   2.771 +    ///The type of the map that stores the last
   2.772 +    ///arcs of the shortest paths.
   2.773 +    ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
   2.774 +    ///
   2.775 +    typedef NullMap<typename Digraph::Node,typename GR::Arc> PredMap;
   2.776 +    ///Instantiates a PredMap.
   2.777 + 
   2.778 +    ///This function instantiates a \ref PredMap. 
   2.779 +    ///\param g is the digraph, to which we would like to define the PredMap.
   2.780 +    ///\todo The digraph alone may be insufficient to initialize
   2.781 +#ifdef DOXYGEN
   2.782 +    static PredMap *createPredMap(const GR &g) 
   2.783 +#else
   2.784 +    static PredMap *createPredMap(const GR &) 
   2.785 +#endif
   2.786 +    {
   2.787 +      return new PredMap();
   2.788 +    }
   2.789 +
   2.790 +    ///The type of the map that indicates which nodes are processed.
   2.791 + 
   2.792 +    ///The type of the map that indicates which nodes are processed.
   2.793 +    ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
   2.794 +    ///\todo named parameter to set this type, function to read and write.
   2.795 +    typedef NullMap<typename Digraph::Node,bool> ProcessedMap;
   2.796 +    ///Instantiates a ProcessedMap.
   2.797 + 
   2.798 +    ///This function instantiates a \ref ProcessedMap. 
   2.799 +    ///\param g is the digraph, to which
   2.800 +    ///we would like to define the \ref ProcessedMap
   2.801 +#ifdef DOXYGEN
   2.802 +    static ProcessedMap *createProcessedMap(const GR &g)
   2.803 +#else
   2.804 +    static ProcessedMap *createProcessedMap(const GR &)
   2.805 +#endif
   2.806 +    {
   2.807 +      return new ProcessedMap();
   2.808 +    }
   2.809 +    ///The type of the map that indicates which nodes are reached.
   2.810 + 
   2.811 +    ///The type of the map that indicates which nodes are reached.
   2.812 +    ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
   2.813 +    ///\todo named parameter to set this type, function to read and write.
   2.814 +    typedef typename Digraph::template NodeMap<bool> ReachedMap;
   2.815 +    ///Instantiates a ReachedMap.
   2.816 + 
   2.817 +    ///This function instantiates a \ref ReachedMap. 
   2.818 +    ///\param G is the digraph, to which
   2.819 +    ///we would like to define the \ref ReachedMap.
   2.820 +    static ReachedMap *createReachedMap(const GR &G)
   2.821 +    {
   2.822 +      return new ReachedMap(G);
   2.823 +    }
   2.824 +    ///The type of the map that stores the dists of the nodes.
   2.825 + 
   2.826 +    ///The type of the map that stores the dists of the nodes.
   2.827 +    ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
   2.828 +    ///
   2.829 +    typedef NullMap<typename Digraph::Node,int> DistMap;
   2.830 +    ///Instantiates a DistMap.
   2.831 + 
   2.832 +    ///This function instantiates a \ref DistMap. 
   2.833 +    ///\param g is the digraph, to which we would like to define the \ref DistMap
   2.834 +#ifdef DOXYGEN
   2.835 +    static DistMap *createDistMap(const GR &g)
   2.836 +#else
   2.837 +    static DistMap *createDistMap(const GR &)
   2.838 +#endif
   2.839 +    {
   2.840 +      return new DistMap();
   2.841 +    }
   2.842 +  };
   2.843 +  
   2.844 +  /// Default traits used by \ref BfsWizard
   2.845 +
   2.846 +  /// To make it easier to use Bfs algorithm
   2.847 +  ///we have created a wizard class.
   2.848 +  /// This \ref BfsWizard class needs default traits,
   2.849 +  ///as well as the \ref Bfs class.
   2.850 +  /// The \ref BfsWizardBase is a class to be the default traits of the
   2.851 +  /// \ref BfsWizard class.
   2.852 +  template<class GR>
   2.853 +  class BfsWizardBase : public BfsWizardDefaultTraits<GR>
   2.854 +  {
   2.855 +
   2.856 +    typedef BfsWizardDefaultTraits<GR> Base;
   2.857 +  protected:
   2.858 +    /// Type of the nodes in the digraph.
   2.859 +    typedef typename Base::Digraph::Node Node;
   2.860 +
   2.861 +    /// Pointer to the underlying digraph.
   2.862 +    void *_g;
   2.863 +    ///Pointer to the map of reached nodes.
   2.864 +    void *_reached;
   2.865 +    ///Pointer to the map of processed nodes.
   2.866 +    void *_processed;
   2.867 +    ///Pointer to the map of predecessors arcs.
   2.868 +    void *_pred;
   2.869 +    ///Pointer to the map of distances.
   2.870 +    void *_dist;
   2.871 +    ///Pointer to the source node.
   2.872 +    Node _source;
   2.873 +    
   2.874 +    public:
   2.875 +    /// Constructor.
   2.876 +    
   2.877 +    /// This constructor does not require parameters, therefore it initiates
   2.878 +    /// all of the attributes to default values (0, INVALID).
   2.879 +    BfsWizardBase() : _g(0), _reached(0), _processed(0), _pred(0),
   2.880 +			   _dist(0), _source(INVALID) {}
   2.881 +
   2.882 +    /// Constructor.
   2.883 +    
   2.884 +    /// This constructor requires some parameters,
   2.885 +    /// listed in the parameters list.
   2.886 +    /// Others are initiated to 0.
   2.887 +    /// \param g is the initial value of  \ref _g
   2.888 +    /// \param s is the initial value of  \ref _source
   2.889 +    BfsWizardBase(const GR &g, Node s=INVALID) :
   2.890 +      _g(reinterpret_cast<void*>(const_cast<GR*>(&g))), 
   2.891 +      _reached(0), _processed(0), _pred(0), _dist(0), _source(s) {}
   2.892 +
   2.893 +  };
   2.894 +  
   2.895 +  /// A class to make the usage of Bfs algorithm easier
   2.896 +
   2.897 +  /// This class is created to make it easier to use Bfs algorithm.
   2.898 +  /// It uses the functions and features of the plain \ref Bfs,
   2.899 +  /// but it is much simpler to use it.
   2.900 +  ///
   2.901 +  /// Simplicity means that the way to change the types defined
   2.902 +  /// in the traits class is based on functions that returns the new class
   2.903 +  /// and not on templatable built-in classes.
   2.904 +  /// When using the plain \ref Bfs
   2.905 +  /// the new class with the modified type comes from
   2.906 +  /// the original class by using the ::
   2.907 +  /// operator. In the case of \ref BfsWizard only
   2.908 +  /// a function have to be called and it will
   2.909 +  /// return the needed class.
   2.910 +  ///
   2.911 +  /// It does not have own \ref run method. When its \ref run method is called
   2.912 +  /// it initiates a plain \ref Bfs class, and calls the \ref Bfs::run
   2.913 +  /// method of it.
   2.914 +  template<class TR>
   2.915 +  class BfsWizard : public TR
   2.916 +  {
   2.917 +    typedef TR Base;
   2.918 +
   2.919 +    ///The type of the underlying digraph.
   2.920 +    typedef typename TR::Digraph Digraph;
   2.921 +    //\e
   2.922 +    typedef typename Digraph::Node Node;
   2.923 +    //\e
   2.924 +    typedef typename Digraph::NodeIt NodeIt;
   2.925 +    //\e
   2.926 +    typedef typename Digraph::Arc Arc;
   2.927 +    //\e
   2.928 +    typedef typename Digraph::OutArcIt OutArcIt;
   2.929 +    
   2.930 +    ///\brief The type of the map that stores
   2.931 +    ///the reached nodes
   2.932 +    typedef typename TR::ReachedMap ReachedMap;
   2.933 +    ///\brief The type of the map that stores
   2.934 +    ///the processed nodes
   2.935 +    typedef typename TR::ProcessedMap ProcessedMap;
   2.936 +    ///\brief The type of the map that stores the last
   2.937 +    ///arcs of the shortest paths.
   2.938 +    typedef typename TR::PredMap PredMap;
   2.939 +    ///The type of the map that stores the dists of the nodes.
   2.940 +    typedef typename TR::DistMap DistMap;
   2.941 +
   2.942 +  public:
   2.943 +    /// Constructor.
   2.944 +    BfsWizard() : TR() {}
   2.945 +
   2.946 +    /// Constructor that requires parameters.
   2.947 +
   2.948 +    /// Constructor that requires parameters.
   2.949 +    /// These parameters will be the default values for the traits class.
   2.950 +    BfsWizard(const Digraph &g, Node s=INVALID) :
   2.951 +      TR(g,s) {}
   2.952 +
   2.953 +    ///Copy constructor
   2.954 +    BfsWizard(const TR &b) : TR(b) {}
   2.955 +
   2.956 +    ~BfsWizard() {}
   2.957 +
   2.958 +    ///Runs Bfs algorithm from a given node.
   2.959 +    
   2.960 +    ///Runs Bfs algorithm from a given node.
   2.961 +    ///The node can be given by the \ref source function.
   2.962 +    void run()
   2.963 +    {
   2.964 +      if(Base::_source==INVALID) throw UninitializedParameter();
   2.965 +      Bfs<Digraph,TR> alg(*reinterpret_cast<const Digraph*>(Base::_g));
   2.966 +      if(Base::_reached)
   2.967 +	alg.reachedMap(*reinterpret_cast<ReachedMap*>(Base::_reached));
   2.968 +      if(Base::_processed) 
   2.969 +        alg.processedMap(*reinterpret_cast<ProcessedMap*>(Base::_processed));
   2.970 +      if(Base::_pred) 
   2.971 +        alg.predMap(*reinterpret_cast<PredMap*>(Base::_pred));
   2.972 +      if(Base::_dist) 
   2.973 +        alg.distMap(*reinterpret_cast<DistMap*>(Base::_dist));
   2.974 +      alg.run(Base::_source);
   2.975 +    }
   2.976 +
   2.977 +    ///Runs Bfs algorithm from the given node.
   2.978 +
   2.979 +    ///Runs Bfs algorithm from the given node.
   2.980 +    ///\param s is the given source.
   2.981 +    void run(Node s)
   2.982 +    {
   2.983 +      Base::_source=s;
   2.984 +      run();
   2.985 +    }
   2.986 +
   2.987 +    template<class T>
   2.988 +    struct DefPredMapBase : public Base {
   2.989 +      typedef T PredMap;
   2.990 +      static PredMap *createPredMap(const Digraph &) { return 0; };
   2.991 +      DefPredMapBase(const TR &b) : TR(b) {}
   2.992 +    };
   2.993 +    
   2.994 +    ///\brief \ref named-templ-param "Named parameter"
   2.995 +    ///function for setting PredMap
   2.996 +    ///
   2.997 +    /// \ref named-templ-param "Named parameter"
   2.998 +    ///function for setting PredMap
   2.999 +    ///
  2.1000 +    template<class T>
  2.1001 +    BfsWizard<DefPredMapBase<T> > predMap(const T &t) 
  2.1002 +    {
  2.1003 +      Base::_pred=reinterpret_cast<void*>(const_cast<T*>(&t));
  2.1004 +      return BfsWizard<DefPredMapBase<T> >(*this);
  2.1005 +    }
  2.1006 +    
  2.1007 + 
  2.1008 +    template<class T>
  2.1009 +    struct DefReachedMapBase : public Base {
  2.1010 +      typedef T ReachedMap;
  2.1011 +      static ReachedMap *createReachedMap(const Digraph &) { return 0; };
  2.1012 +      DefReachedMapBase(const TR &b) : TR(b) {}
  2.1013 +    };
  2.1014 +    
  2.1015 +    ///\brief \ref named-templ-param "Named parameter"
  2.1016 +    ///function for setting ReachedMap
  2.1017 +    ///
  2.1018 +    /// \ref named-templ-param "Named parameter"
  2.1019 +    ///function for setting ReachedMap
  2.1020 +    ///
  2.1021 +    template<class T>
  2.1022 +    BfsWizard<DefReachedMapBase<T> > reachedMap(const T &t) 
  2.1023 +    {
  2.1024 +      Base::_pred=reinterpret_cast<void*>(const_cast<T*>(&t));
  2.1025 +      return BfsWizard<DefReachedMapBase<T> >(*this);
  2.1026 +    }
  2.1027 +    
  2.1028 +
  2.1029 +    template<class T>
  2.1030 +    struct DefProcessedMapBase : public Base {
  2.1031 +      typedef T ProcessedMap;
  2.1032 +      static ProcessedMap *createProcessedMap(const Digraph &) { return 0; };
  2.1033 +      DefProcessedMapBase(const TR &b) : TR(b) {}
  2.1034 +    };
  2.1035 +    
  2.1036 +    ///\brief \ref named-templ-param "Named parameter"
  2.1037 +    ///function for setting ProcessedMap
  2.1038 +    ///
  2.1039 +    /// \ref named-templ-param "Named parameter"
  2.1040 +    ///function for setting ProcessedMap
  2.1041 +    ///
  2.1042 +    template<class T>
  2.1043 +    BfsWizard<DefProcessedMapBase<T> > processedMap(const T &t) 
  2.1044 +    {
  2.1045 +      Base::_pred=reinterpret_cast<void*>(const_cast<T*>(&t));
  2.1046 +      return BfsWizard<DefProcessedMapBase<T> >(*this);
  2.1047 +    }
  2.1048 +    
  2.1049 +   
  2.1050 +    template<class T>
  2.1051 +    struct DefDistMapBase : public Base {
  2.1052 +      typedef T DistMap;
  2.1053 +      static DistMap *createDistMap(const Digraph &) { return 0; };
  2.1054 +      DefDistMapBase(const TR &b) : TR(b) {}
  2.1055 +    };
  2.1056 +    
  2.1057 +    ///\brief \ref named-templ-param "Named parameter"
  2.1058 +    ///function for setting DistMap type
  2.1059 +    ///
  2.1060 +    /// \ref named-templ-param "Named parameter"
  2.1061 +    ///function for setting DistMap type
  2.1062 +    ///
  2.1063 +    template<class T>
  2.1064 +    BfsWizard<DefDistMapBase<T> > distMap(const T &t) 
  2.1065 +    {
  2.1066 +      Base::_dist=reinterpret_cast<void*>(const_cast<T*>(&t));
  2.1067 +      return BfsWizard<DefDistMapBase<T> >(*this);
  2.1068 +    }
  2.1069 +    
  2.1070 +    /// Sets the source node, from which the Bfs algorithm runs.
  2.1071 +
  2.1072 +    /// Sets the source node, from which the Bfs algorithm runs.
  2.1073 +    /// \param s is the source node.
  2.1074 +    BfsWizard<TR> &source(Node s) 
  2.1075 +    {
  2.1076 +      Base::_source=s;
  2.1077 +      return *this;
  2.1078 +    }
  2.1079 +    
  2.1080 +  };
  2.1081 +  
  2.1082 +  ///Function type interface for Bfs algorithm.
  2.1083 +
  2.1084 +  /// \ingroup search
  2.1085 +  ///Function type interface for Bfs algorithm.
  2.1086 +  ///
  2.1087 +  ///This function also has several
  2.1088 +  ///\ref named-templ-func-param "named parameters",
  2.1089 +  ///they are declared as the members of class \ref BfsWizard.
  2.1090 +  ///The following
  2.1091 +  ///example shows how to use these parameters.
  2.1092 +  ///\code
  2.1093 +  ///  bfs(g,source).predMap(preds).run();
  2.1094 +  ///\endcode
  2.1095 +  ///\warning Don't forget to put the \ref BfsWizard::run() "run()"
  2.1096 +  ///to the end of the parameter list.
  2.1097 +  ///\sa BfsWizard
  2.1098 +  ///\sa Bfs
  2.1099 +  template<class GR>
  2.1100 +  BfsWizard<BfsWizardBase<GR> >
  2.1101 +  bfs(const GR &g,typename GR::Node s=INVALID)
  2.1102 +  {
  2.1103 +    return BfsWizard<BfsWizardBase<GR> >(g,s);
  2.1104 +  }
  2.1105 +
  2.1106 +#ifdef DOXYGEN
  2.1107 +  /// \brief Visitor class for bfs.
  2.1108 +  ///  
  2.1109 +  /// This class defines the interface of the BfsVisit events, and
  2.1110 +  /// it could be the base of a real Visitor class.
  2.1111 +  template <typename _Digraph>
  2.1112 +  struct BfsVisitor {
  2.1113 +    typedef _Digraph Digraph;
  2.1114 +    typedef typename Digraph::Arc Arc;
  2.1115 +    typedef typename Digraph::Node Node;
  2.1116 +    /// \brief Called when the arc reach a node.
  2.1117 +    /// 
  2.1118 +    /// It is called when the bfs find an arc which target is not
  2.1119 +    /// reached yet.
  2.1120 +    void discover(const Arc& arc) {}
  2.1121 +    /// \brief Called when the node reached first time.
  2.1122 +    /// 
  2.1123 +    /// It is Called when the node reached first time.
  2.1124 +    void reach(const Node& node) {}
  2.1125 +    /// \brief Called when the arc examined but target of the arc 
  2.1126 +    /// already discovered.
  2.1127 +    /// 
  2.1128 +    /// It called when the arc examined but the target of the arc 
  2.1129 +    /// already discovered.
  2.1130 +    void examine(const Arc& arc) {}
  2.1131 +    /// \brief Called for the source node of the bfs.
  2.1132 +    /// 
  2.1133 +    /// It is called for the source node of the bfs.
  2.1134 +    void start(const Node& node) {}
  2.1135 +    /// \brief Called when the node processed.
  2.1136 +    /// 
  2.1137 +    /// It is Called when the node processed.
  2.1138 +    void process(const Node& node) {}
  2.1139 +  };
  2.1140 +#else
  2.1141 +  template <typename _Digraph>
  2.1142 +  struct BfsVisitor {
  2.1143 +    typedef _Digraph Digraph;
  2.1144 +    typedef typename Digraph::Arc Arc;
  2.1145 +    typedef typename Digraph::Node Node;
  2.1146 +    void discover(const Arc&) {}
  2.1147 +    void reach(const Node&) {}
  2.1148 +    void examine(const Arc&) {}
  2.1149 +    void start(const Node&) {}
  2.1150 +    void process(const Node&) {}
  2.1151 +
  2.1152 +    template <typename _Visitor>
  2.1153 +    struct Constraints {
  2.1154 +      void constraints() {
  2.1155 +	Arc arc;
  2.1156 +	Node node;
  2.1157 +	visitor.discover(arc);
  2.1158 +	visitor.reach(node);
  2.1159 +	visitor.examine(arc);
  2.1160 +	visitor.start(node);
  2.1161 +        visitor.process(node);
  2.1162 +      }
  2.1163 +      _Visitor& visitor;
  2.1164 +    };
  2.1165 +  };
  2.1166 +#endif
  2.1167 +
  2.1168 +  /// \brief Default traits class of BfsVisit class.
  2.1169 +  ///
  2.1170 +  /// Default traits class of BfsVisit class.
  2.1171 +  /// \param _Digraph Digraph type.
  2.1172 +  template<class _Digraph>
  2.1173 +  struct BfsVisitDefaultTraits {
  2.1174 +
  2.1175 +    /// \brief The digraph type the algorithm runs on. 
  2.1176 +    typedef _Digraph Digraph;
  2.1177 +
  2.1178 +    /// \brief The type of the map that indicates which nodes are reached.
  2.1179 +    /// 
  2.1180 +    /// The type of the map that indicates which nodes are reached.
  2.1181 +    /// It must meet the \ref concepts::WriteMap "WriteMap" concept.
  2.1182 +    /// \todo named parameter to set this type, function to read and write.
  2.1183 +    typedef typename Digraph::template NodeMap<bool> ReachedMap;
  2.1184 +
  2.1185 +    /// \brief Instantiates a ReachedMap.
  2.1186 +    ///
  2.1187 +    /// This function instantiates a \ref ReachedMap. 
  2.1188 +    /// \param digraph is the digraph, to which
  2.1189 +    /// we would like to define the \ref ReachedMap.
  2.1190 +    static ReachedMap *createReachedMap(const Digraph &digraph) {
  2.1191 +      return new ReachedMap(digraph);
  2.1192 +    }
  2.1193 +
  2.1194 +  };
  2.1195 +
  2.1196 +  /// \ingroup search
  2.1197 +  ///  
  2.1198 +  /// \brief %BFS Visit algorithm class.
  2.1199 +  ///  
  2.1200 +  /// This class provides an efficient implementation of the %BFS algorithm
  2.1201 +  /// with visitor interface.
  2.1202 +  ///
  2.1203 +  /// The %BfsVisit class provides an alternative interface to the Bfs
  2.1204 +  /// class. It works with callback mechanism, the BfsVisit object calls
  2.1205 +  /// on every bfs event the \c Visitor class member functions. 
  2.1206 +  ///
  2.1207 +  /// \param _Digraph The digraph type the algorithm runs on. The default value is
  2.1208 +  /// \ref ListDigraph. The value of _Digraph is not used directly by Bfs, it
  2.1209 +  /// is only passed to \ref BfsDefaultTraits.
  2.1210 +  /// \param _Visitor The Visitor object for the algorithm. The 
  2.1211 +  /// \ref BfsVisitor "BfsVisitor<_Digraph>" is an empty Visitor which
  2.1212 +  /// does not observe the Bfs events. If you want to observe the bfs
  2.1213 +  /// events you should implement your own Visitor class.
  2.1214 +  /// \param _Traits Traits class to set various data types used by the 
  2.1215 +  /// algorithm. The default traits class is
  2.1216 +  /// \ref BfsVisitDefaultTraits "BfsVisitDefaultTraits<_Digraph>".
  2.1217 +  /// See \ref BfsVisitDefaultTraits for the documentation of
  2.1218 +  /// a Bfs visit traits class.
  2.1219 +  ///
  2.1220 +  /// \author Jacint Szabo, Alpar Juttner and Balazs Dezso
  2.1221 +#ifdef DOXYGEN
  2.1222 +  template <typename _Digraph, typename _Visitor, typename _Traits>
  2.1223 +#else
  2.1224 +  template <typename _Digraph = ListDigraph,
  2.1225 +	    typename _Visitor = BfsVisitor<_Digraph>,
  2.1226 +	    typename _Traits = BfsDefaultTraits<_Digraph> >
  2.1227 +#endif
  2.1228 +  class BfsVisit {
  2.1229 +  public:
  2.1230 +    
  2.1231 +    /// \brief \ref Exception for uninitialized parameters.
  2.1232 +    ///
  2.1233 +    /// This error represents problems in the initialization
  2.1234 +    /// of the parameters of the algorithms.
  2.1235 +    class UninitializedParameter : public lemon::UninitializedParameter {
  2.1236 +    public:
  2.1237 +      virtual const char* what() const throw() 
  2.1238 +      {
  2.1239 +	return "lemon::BfsVisit::UninitializedParameter";
  2.1240 +      }
  2.1241 +    };
  2.1242 +
  2.1243 +    typedef _Traits Traits;
  2.1244 +
  2.1245 +    typedef typename Traits::Digraph Digraph;
  2.1246 +
  2.1247 +    typedef _Visitor Visitor;
  2.1248 +
  2.1249 +    ///The type of the map indicating which nodes are reached.
  2.1250 +    typedef typename Traits::ReachedMap ReachedMap;
  2.1251 +
  2.1252 +  private:
  2.1253 +
  2.1254 +    typedef typename Digraph::Node Node;
  2.1255 +    typedef typename Digraph::NodeIt NodeIt;
  2.1256 +    typedef typename Digraph::Arc Arc;
  2.1257 +    typedef typename Digraph::OutArcIt OutArcIt;
  2.1258 +
  2.1259 +    /// Pointer to the underlying digraph.
  2.1260 +    const Digraph *_digraph;
  2.1261 +    /// Pointer to the visitor object.
  2.1262 +    Visitor *_visitor;
  2.1263 +    ///Pointer to the map of reached status of the nodes.
  2.1264 +    ReachedMap *_reached;
  2.1265 +    ///Indicates if \ref _reached is locally allocated (\c true) or not.
  2.1266 +    bool local_reached;
  2.1267 +
  2.1268 +    std::vector<typename Digraph::Node> _list;
  2.1269 +    int _list_front, _list_back;
  2.1270 +
  2.1271 +    /// \brief Creates the maps if necessary.
  2.1272 +    ///
  2.1273 +    /// Creates the maps if necessary.
  2.1274 +    void create_maps() {
  2.1275 +      if(!_reached) {
  2.1276 +	local_reached = true;
  2.1277 +	_reached = Traits::createReachedMap(*_digraph);
  2.1278 +      }
  2.1279 +    }
  2.1280 +
  2.1281 +  protected:
  2.1282 +
  2.1283 +    BfsVisit() {}
  2.1284 +    
  2.1285 +  public:
  2.1286 +
  2.1287 +    typedef BfsVisit Create;
  2.1288 +
  2.1289 +    /// \name Named template parameters
  2.1290 +
  2.1291 +    ///@{
  2.1292 +    template <class T>
  2.1293 +    struct DefReachedMapTraits : public Traits {
  2.1294 +      typedef T ReachedMap;
  2.1295 +      static ReachedMap *createReachedMap(const Digraph &digraph) {
  2.1296 +	throw UninitializedParameter();
  2.1297 +      }
  2.1298 +    };
  2.1299 +    /// \brief \ref named-templ-param "Named parameter" for setting 
  2.1300 +    /// ReachedMap type
  2.1301 +    ///
  2.1302 +    /// \ref named-templ-param "Named parameter" for setting ReachedMap type
  2.1303 +    template <class T>
  2.1304 +    struct DefReachedMap : public BfsVisit< Digraph, Visitor,
  2.1305 +					    DefReachedMapTraits<T> > {
  2.1306 +      typedef BfsVisit< Digraph, Visitor, DefReachedMapTraits<T> > Create;
  2.1307 +    };
  2.1308 +    ///@}
  2.1309 +
  2.1310 +  public:      
  2.1311 +    
  2.1312 +    /// \brief Constructor.
  2.1313 +    ///
  2.1314 +    /// Constructor.
  2.1315 +    ///
  2.1316 +    /// \param digraph the digraph the algorithm will run on.
  2.1317 +    /// \param visitor The visitor of the algorithm.
  2.1318 +    ///
  2.1319 +    BfsVisit(const Digraph& digraph, Visitor& visitor) 
  2.1320 +      : _digraph(&digraph), _visitor(&visitor),
  2.1321 +	_reached(0), local_reached(false) {}
  2.1322 +    
  2.1323 +    /// \brief Destructor.
  2.1324 +    ///
  2.1325 +    /// Destructor.
  2.1326 +    ~BfsVisit() {
  2.1327 +      if(local_reached) delete _reached;
  2.1328 +    }
  2.1329 +
  2.1330 +    /// \brief Sets the map indicating if a node is reached.
  2.1331 +    ///
  2.1332 +    /// Sets the map indicating if a node is reached.
  2.1333 +    /// If you don't use this function before calling \ref run(),
  2.1334 +    /// it will allocate one. The destuctor deallocates this
  2.1335 +    /// automatically allocated map, of course.
  2.1336 +    /// \return <tt> (*this) </tt>
  2.1337 +    BfsVisit &reachedMap(ReachedMap &m) {
  2.1338 +      if(local_reached) {
  2.1339 +	delete _reached;
  2.1340 +	local_reached = false;
  2.1341 +      }
  2.1342 +      _reached = &m;
  2.1343 +      return *this;
  2.1344 +    }
  2.1345 +
  2.1346 +  public:
  2.1347 +    /// \name Execution control
  2.1348 +    /// The simplest way to execute the algorithm is to use
  2.1349 +    /// one of the member functions called \c run(...).
  2.1350 +    /// \n
  2.1351 +    /// If you need more control on the execution,
  2.1352 +    /// first you must call \ref init(), then you can adda source node
  2.1353 +    /// with \ref addSource().
  2.1354 +    /// Finally \ref start() will perform the actual path
  2.1355 +    /// computation.
  2.1356 +
  2.1357 +    /// @{
  2.1358 +    /// \brief Initializes the internal data structures.
  2.1359 +    ///
  2.1360 +    /// Initializes the internal data structures.
  2.1361 +    ///
  2.1362 +    void init() {
  2.1363 +      create_maps();
  2.1364 +      _list.resize(countNodes(*_digraph));
  2.1365 +      _list_front = _list_back = -1;
  2.1366 +      for (NodeIt u(*_digraph) ; u != INVALID ; ++u) {
  2.1367 +	_reached->set(u, false);
  2.1368 +      }
  2.1369 +    }
  2.1370 +    
  2.1371 +    /// \brief Adds a new source node.
  2.1372 +    ///
  2.1373 +    /// Adds a new source node to the set of nodes to be processed.
  2.1374 +    void addSource(Node s) {
  2.1375 +      if(!(*_reached)[s]) {
  2.1376 +	  _reached->set(s,true);
  2.1377 +	  _visitor->start(s);
  2.1378 +	  _visitor->reach(s);
  2.1379 +          _list[++_list_back] = s;
  2.1380 +	}
  2.1381 +    }
  2.1382 +    
  2.1383 +    /// \brief Processes the next node.
  2.1384 +    ///
  2.1385 +    /// Processes the next node.
  2.1386 +    ///
  2.1387 +    /// \return The processed node.
  2.1388 +    ///
  2.1389 +    /// \pre The queue must not be empty!
  2.1390 +    Node processNextNode() { 
  2.1391 +      Node n = _list[++_list_front];
  2.1392 +      _visitor->process(n);
  2.1393 +      Arc e;
  2.1394 +      for (_digraph->firstOut(e, n); e != INVALID; _digraph->nextOut(e)) {
  2.1395 +        Node m = _digraph->target(e);
  2.1396 +        if (!(*_reached)[m]) {
  2.1397 +          _visitor->discover(e);
  2.1398 +          _visitor->reach(m);
  2.1399 +          _reached->set(m, true);
  2.1400 +          _list[++_list_back] = m;
  2.1401 +        } else {
  2.1402 +          _visitor->examine(e);
  2.1403 +        }
  2.1404 +      }
  2.1405 +      return n;
  2.1406 +    }
  2.1407 +
  2.1408 +    /// \brief Processes the next node.
  2.1409 +    ///
  2.1410 +    /// Processes the next node. And checks that the given target node
  2.1411 +    /// is reached. If the target node is reachable from the processed
  2.1412 +    /// node then the reached parameter will be set true. The reached
  2.1413 +    /// parameter should be initially false.
  2.1414 +    ///
  2.1415 +    /// \param target The target node.
  2.1416 +    /// \retval reach Indicates that the target node is reached.
  2.1417 +    /// \return The processed node.
  2.1418 +    ///
  2.1419 +    /// \warning The queue must not be empty!
  2.1420 +    Node processNextNode(Node target, bool& reach) {
  2.1421 +      Node n = _list[++_list_front];
  2.1422 +      _visitor->process(n);
  2.1423 +      Arc e;
  2.1424 +      for (_digraph->firstOut(e, n); e != INVALID; _digraph->nextOut(e)) {
  2.1425 +        Node m = _digraph->target(e);
  2.1426 +        if (!(*_reached)[m]) {
  2.1427 +          _visitor->discover(e);
  2.1428 +          _visitor->reach(m);
  2.1429 +          _reached->set(m, true);
  2.1430 +          _list[++_list_back] = m;
  2.1431 +          reach = reach || (target == m);
  2.1432 +        } else {
  2.1433 +          _visitor->examine(e);
  2.1434 +        }
  2.1435 +      }
  2.1436 +      return n;
  2.1437 +    }
  2.1438 +
  2.1439 +    /// \brief Processes the next node.
  2.1440 +    ///
  2.1441 +    /// Processes the next node. And checks that at least one of
  2.1442 +    /// reached node has true value in the \c nm node map. If one node
  2.1443 +    /// with true value is reachable from the processed node then the
  2.1444 +    /// rnode parameter will be set to the first of such nodes.
  2.1445 +    ///
  2.1446 +    /// \param nm The node map of possible targets.
  2.1447 +    /// \retval rnode The reached target node.
  2.1448 +    /// \return The processed node.
  2.1449 +    ///
  2.1450 +    /// \warning The queue must not be empty!
  2.1451 +    template <typename NM>
  2.1452 +    Node processNextNode(const NM& nm, Node& rnode) {
  2.1453 +      Node n = _list[++_list_front];
  2.1454 +      _visitor->process(n);
  2.1455 +      Arc e;
  2.1456 +      for (_digraph->firstOut(e, n); e != INVALID; _digraph->nextOut(e)) {
  2.1457 +        Node m = _digraph->target(e);
  2.1458 +        if (!(*_reached)[m]) {
  2.1459 +          _visitor->discover(e);
  2.1460 +          _visitor->reach(m);
  2.1461 +          _reached->set(m, true);
  2.1462 +          _list[++_list_back] = m;
  2.1463 +          if (nm[m] && rnode == INVALID) rnode = m;
  2.1464 +        } else {
  2.1465 +          _visitor->examine(e);
  2.1466 +        }
  2.1467 +      }
  2.1468 +      return n;
  2.1469 +    }
  2.1470 +
  2.1471 +    /// \brief Next node to be processed.
  2.1472 +    ///
  2.1473 +    /// Next node to be processed.
  2.1474 +    ///
  2.1475 +    /// \return The next node to be processed or INVALID if the stack is
  2.1476 +    /// empty.
  2.1477 +    Node nextNode() { 
  2.1478 +      return _list_front != _list_back ? _list[_list_front + 1] : INVALID;
  2.1479 +    }
  2.1480 +
  2.1481 +    /// \brief Returns \c false if there are nodes
  2.1482 +    /// to be processed in the queue
  2.1483 +    ///
  2.1484 +    /// Returns \c false if there are nodes
  2.1485 +    /// to be processed in the queue
  2.1486 +    bool emptyQueue() { return _list_front == _list_back; }
  2.1487 +
  2.1488 +    /// \brief Returns the number of the nodes to be processed.
  2.1489 +    ///
  2.1490 +    /// Returns the number of the nodes to be processed in the queue.
  2.1491 +    int queueSize() { return _list_back - _list_front; }
  2.1492 +    
  2.1493 +    /// \brief Executes the algorithm.
  2.1494 +    ///
  2.1495 +    /// Executes the algorithm.
  2.1496 +    ///
  2.1497 +    /// \pre init() must be called and at least one node should be added
  2.1498 +    /// with addSource() before using this function.
  2.1499 +    void start() {
  2.1500 +      while ( !emptyQueue() ) processNextNode();
  2.1501 +    }
  2.1502 +    
  2.1503 +    /// \brief Executes the algorithm until \c dest is reached.
  2.1504 +    ///
  2.1505 +    /// Executes the algorithm until \c dest is reached.
  2.1506 +    ///
  2.1507 +    /// \pre init() must be called and at least one node should be added
  2.1508 +    /// with addSource() before using this function.
  2.1509 +    void start(Node dest) {
  2.1510 +      bool reach = false;
  2.1511 +      while ( !emptyQueue() && !reach ) processNextNode(dest, reach);
  2.1512 +    }
  2.1513 +    
  2.1514 +    /// \brief Executes the algorithm until a condition is met.
  2.1515 +    ///
  2.1516 +    /// Executes the algorithm until a condition is met.
  2.1517 +    ///
  2.1518 +    /// \pre init() must be called and at least one node should be added
  2.1519 +    /// with addSource() before using this function.
  2.1520 +    ///
  2.1521 +    ///\param nm must be a bool (or convertible) node map. The
  2.1522 +    ///algorithm will stop when it reaches a node \c v with
  2.1523 +    /// <tt>nm[v]</tt> true.
  2.1524 +    ///
  2.1525 +    ///\return The reached node \c v with <tt>nm[v]</tt> true or
  2.1526 +    ///\c INVALID if no such node was found.
  2.1527 +    template <typename NM>
  2.1528 +    Node start(const NM &nm) {
  2.1529 +      Node rnode = INVALID;
  2.1530 +      while ( !emptyQueue() && rnode == INVALID ) {
  2.1531 +	processNextNode(nm, rnode);
  2.1532 +      }
  2.1533 +      return rnode;
  2.1534 +    }
  2.1535 +
  2.1536 +    /// \brief Runs %BFSVisit algorithm from node \c s.
  2.1537 +    ///
  2.1538 +    /// This method runs the %BFS algorithm from a root node \c s.
  2.1539 +    /// \note b.run(s) is just a shortcut of the following code.
  2.1540 +    ///\code
  2.1541 +    ///   b.init();
  2.1542 +    ///   b.addSource(s);
  2.1543 +    ///   b.start();
  2.1544 +    ///\endcode
  2.1545 +    void run(Node s) {
  2.1546 +      init();
  2.1547 +      addSource(s);
  2.1548 +      start();
  2.1549 +    }
  2.1550 +
  2.1551 +    /// \brief Runs %BFSVisit algorithm to visit all nodes in the digraph.
  2.1552 +    ///    
  2.1553 +    /// This method runs the %BFS algorithm in order to
  2.1554 +    /// compute the %BFS path to each node. The algorithm computes
  2.1555 +    /// - The %BFS tree.
  2.1556 +    /// - The distance of each node from the root in the %BFS tree.
  2.1557 +    ///
  2.1558 +    ///\note b.run() is just a shortcut of the following code.
  2.1559 +    ///\code
  2.1560 +    ///  b.init();
  2.1561 +    ///  for (NodeIt it(digraph); it != INVALID; ++it) {
  2.1562 +    ///    if (!b.reached(it)) {
  2.1563 +    ///      b.addSource(it);
  2.1564 +    ///      b.start();
  2.1565 +    ///    }
  2.1566 +    ///  }
  2.1567 +    ///\endcode
  2.1568 +    void run() {
  2.1569 +      init();
  2.1570 +      for (NodeIt it(*_digraph); it != INVALID; ++it) {
  2.1571 +        if (!reached(it)) {
  2.1572 +          addSource(it);
  2.1573 +          start();
  2.1574 +        }
  2.1575 +      }
  2.1576 +    }
  2.1577 +    ///@}
  2.1578 +
  2.1579 +    /// \name Query Functions
  2.1580 +    /// The result of the %BFS algorithm can be obtained using these
  2.1581 +    /// functions.\n
  2.1582 +    /// Before the use of these functions,
  2.1583 +    /// either run() or start() must be called.
  2.1584 +    ///@{
  2.1585 +
  2.1586 +    /// \brief Checks if a node is reachable from the root.
  2.1587 +    ///
  2.1588 +    /// Returns \c true if \c v is reachable from the root(s).
  2.1589 +    /// \warning The source nodes are inditated as unreachable.
  2.1590 +    /// \pre Either \ref run() or \ref start()
  2.1591 +    /// must be called before using this function.
  2.1592 +    ///
  2.1593 +    bool reached(Node v) { return (*_reached)[v]; }
  2.1594 +    ///@}
  2.1595 +  };
  2.1596 +
  2.1597 +} //END OF NAMESPACE LEMON
  2.1598 +
  2.1599 +#endif
  2.1600 +
     3.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
     3.2 +++ b/lemon/bin_heap.h	Thu Feb 07 21:37:07 2008 +0000
     3.3 @@ -0,0 +1,346 @@
     3.4 +/* -*- C++ -*-
     3.5 + *
     3.6 + * This file is a part of LEMON, a generic C++ optimization library
     3.7 + *
     3.8 + * Copyright (C) 2003-2008
     3.9 + * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
    3.10 + * (Egervary Research Group on Combinatorial Optimization, EGRES).
    3.11 + *
    3.12 + * Permission to use, modify and distribute this software is granted
    3.13 + * provided that this copyright notice appears in all copies. For
    3.14 + * precise terms see the accompanying LICENSE file.
    3.15 + *
    3.16 + * This software is provided "AS IS" with no warranty of any kind,
    3.17 + * express or implied, and with no claim as to its suitability for any
    3.18 + * purpose.
    3.19 + *
    3.20 + */
    3.21 +
    3.22 +#ifndef LEMON_BIN_HEAP_H
    3.23 +#define LEMON_BIN_HEAP_H
    3.24 +
    3.25 +///\ingroup auxdat
    3.26 +///\file
    3.27 +///\brief Binary Heap implementation.
    3.28 +
    3.29 +#include <vector>
    3.30 +#include <utility>
    3.31 +#include <functional>
    3.32 +
    3.33 +namespace lemon {
    3.34 +
    3.35 +  ///\ingroup auxdat
    3.36 +  ///
    3.37 +  ///\brief A Binary Heap implementation.
    3.38 +  ///
    3.39 +  ///This class implements the \e binary \e heap data structure. A \e heap
    3.40 +  ///is a data structure for storing items with specified values called \e
    3.41 +  ///priorities in such a way that finding the item with minimum priority is
    3.42 +  ///efficient. \c Compare specifies the ordering of the priorities. In a heap
    3.43 +  ///one can change the priority of an item, add or erase an item, etc.
    3.44 +  ///
    3.45 +  ///\param _Prio Type of the priority of the items.
    3.46 +  ///\param _ItemIntMap A read and writable Item int map, used internally
    3.47 +  ///to handle the cross references.
    3.48 +  ///\param _Compare A class for the ordering of the priorities. The
    3.49 +  ///default is \c std::less<_Prio>.
    3.50 +  ///
    3.51 +  ///\sa FibHeap
    3.52 +  ///\sa Dijkstra
    3.53 +  template <typename _Prio, typename _ItemIntMap,
    3.54 +	    typename _Compare = std::less<_Prio> >
    3.55 +  class BinHeap {
    3.56 +
    3.57 +  public:
    3.58 +    ///\e
    3.59 +    typedef _ItemIntMap ItemIntMap;
    3.60 +    ///\e
    3.61 +    typedef _Prio Prio;
    3.62 +    ///\e
    3.63 +    typedef typename ItemIntMap::Key Item;
    3.64 +    ///\e
    3.65 +    typedef std::pair<Item,Prio> Pair;
    3.66 +    ///\e
    3.67 +    typedef _Compare Compare;
    3.68 +
    3.69 +    /// \brief Type to represent the items states.
    3.70 +    ///
    3.71 +    /// Each Item element have a state associated to it. It may be "in heap",
    3.72 +    /// "pre heap" or "post heap". The latter two are indifferent from the
    3.73 +    /// heap's point of view, but may be useful to the user.
    3.74 +    ///
    3.75 +    /// The ItemIntMap \e should be initialized in such way that it maps
    3.76 +    /// PRE_HEAP (-1) to any element to be put in the heap...
    3.77 +    enum State {
    3.78 +      IN_HEAP = 0,
    3.79 +      PRE_HEAP = -1,
    3.80 +      POST_HEAP = -2
    3.81 +    };
    3.82 +
    3.83 +  private:
    3.84 +    std::vector<Pair> data;
    3.85 +    Compare comp;
    3.86 +    ItemIntMap &iim;
    3.87 +
    3.88 +  public:
    3.89 +    /// \brief The constructor.
    3.90 +    ///
    3.91 +    /// The constructor.
    3.92 +    /// \param _iim should be given to the constructor, since it is used
    3.93 +    /// internally to handle the cross references. The value of the map
    3.94 +    /// should be PRE_HEAP (-1) for each element.
    3.95 +    explicit BinHeap(ItemIntMap &_iim) : iim(_iim) {}
    3.96 +    
    3.97 +    /// \brief The constructor.
    3.98 +    ///
    3.99 +    /// The constructor.
   3.100 +    /// \param _iim should be given to the constructor, since it is used
   3.101 +    /// internally to handle the cross references. The value of the map
   3.102 +    /// should be PRE_HEAP (-1) for each element.
   3.103 +    ///
   3.104 +    /// \param _comp The comparator function object.
   3.105 +    BinHeap(ItemIntMap &_iim, const Compare &_comp) 
   3.106 +      : iim(_iim), comp(_comp) {}
   3.107 +
   3.108 +
   3.109 +    /// The number of items stored in the heap.
   3.110 +    ///
   3.111 +    /// \brief Returns the number of items stored in the heap.
   3.112 +    int size() const { return data.size(); }
   3.113 +    
   3.114 +    /// \brief Checks if the heap stores no items.
   3.115 +    ///
   3.116 +    /// Returns \c true if and only if the heap stores no items.
   3.117 +    bool empty() const { return data.empty(); }
   3.118 +
   3.119 +    /// \brief Make empty this heap.
   3.120 +    /// 
   3.121 +    /// Make empty this heap. It does not change the cross reference map.
   3.122 +    /// If you want to reuse what is not surely empty you should first clear
   3.123 +    /// the heap and after that you should set the cross reference map for
   3.124 +    /// each item to \c PRE_HEAP.
   3.125 +    void clear() { 
   3.126 +      data.clear(); 
   3.127 +    }
   3.128 +
   3.129 +  private:
   3.130 +    static int parent(int i) { return (i-1)/2; }
   3.131 +
   3.132 +    static int second_child(int i) { return 2*i+2; }
   3.133 +    bool less(const Pair &p1, const Pair &p2) const {
   3.134 +      return comp(p1.second, p2.second);
   3.135 +    }
   3.136 +
   3.137 +    int bubble_up(int hole, Pair p) {
   3.138 +      int par = parent(hole);
   3.139 +      while( hole>0 && less(p,data[par]) ) {
   3.140 +	move(data[par],hole);
   3.141 +	hole = par;
   3.142 +	par = parent(hole);
   3.143 +      }
   3.144 +      move(p, hole);
   3.145 +      return hole;
   3.146 +    }
   3.147 +
   3.148 +    int bubble_down(int hole, Pair p, int length) {
   3.149 +      int child = second_child(hole);
   3.150 +      while(child < length) {
   3.151 +	if( less(data[child-1], data[child]) ) {
   3.152 +	  --child;
   3.153 +	}
   3.154 +	if( !less(data[child], p) )
   3.155 +	  goto ok;
   3.156 +	move(data[child], hole);
   3.157 +	hole = child;
   3.158 +	child = second_child(hole);
   3.159 +      }
   3.160 +      child--;
   3.161 +      if( child<length && less(data[child], p) ) {
   3.162 +	move(data[child], hole);
   3.163 +	hole=child;
   3.164 +      }
   3.165 +    ok:
   3.166 +      move(p, hole);
   3.167 +      return hole;
   3.168 +    }
   3.169 +
   3.170 +    void move(const Pair &p, int i) {
   3.171 +      data[i] = p;
   3.172 +      iim.set(p.first, i);
   3.173 +    }
   3.174 +
   3.175 +  public:
   3.176 +    /// \brief Insert a pair of item and priority into the heap.
   3.177 +    ///
   3.178 +    /// Adds \c p.first to the heap with priority \c p.second.
   3.179 +    /// \param p The pair to insert.
   3.180 +    void push(const Pair &p) {
   3.181 +      int n = data.size();
   3.182 +      data.resize(n+1);
   3.183 +      bubble_up(n, p);
   3.184 +    }
   3.185 +
   3.186 +    /// \brief Insert an item into the heap with the given heap.
   3.187 +    ///    
   3.188 +    /// Adds \c i to the heap with priority \c p. 
   3.189 +    /// \param i The item to insert.
   3.190 +    /// \param p The priority of the item.
   3.191 +    void push(const Item &i, const Prio &p) { push(Pair(i,p)); }
   3.192 +
   3.193 +    /// \brief Returns the item with minimum priority relative to \c Compare.
   3.194 +    ///
   3.195 +    /// This method returns the item with minimum priority relative to \c
   3.196 +    /// Compare.  
   3.197 +    /// \pre The heap must be nonempty.  
   3.198 +    Item top() const {
   3.199 +      return data[0].first;
   3.200 +    }
   3.201 +
   3.202 +    /// \brief Returns the minimum priority relative to \c Compare.
   3.203 +    ///
   3.204 +    /// It returns the minimum priority relative to \c Compare.
   3.205 +    /// \pre The heap must be nonempty.
   3.206 +    Prio prio() const {
   3.207 +      return data[0].second;
   3.208 +    }
   3.209 +
   3.210 +    /// \brief Deletes the item with minimum priority relative to \c Compare.
   3.211 +    ///
   3.212 +    /// This method deletes the item with minimum priority relative to \c
   3.213 +    /// Compare from the heap.  
   3.214 +    /// \pre The heap must be non-empty.  
   3.215 +    void pop() {
   3.216 +      int n = data.size()-1;
   3.217 +      iim.set(data[0].first, POST_HEAP);
   3.218 +      if (n > 0) {
   3.219 +	bubble_down(0, data[n], n);
   3.220 +      }
   3.221 +      data.pop_back();
   3.222 +    }
   3.223 +
   3.224 +    /// \brief Deletes \c i from the heap.
   3.225 +    ///
   3.226 +    /// This method deletes item \c i from the heap.
   3.227 +    /// \param i The item to erase.
   3.228 +    /// \pre The item should be in the heap.
   3.229 +    void erase(const Item &i) {
   3.230 +      int h = iim[i];
   3.231 +      int n = data.size()-1;
   3.232 +      iim.set(data[h].first, POST_HEAP);
   3.233 +      if( h < n ) {
   3.234 +	if ( bubble_up(h, data[n]) == h) {
   3.235 +	  bubble_down(h, data[n], n);
   3.236 +	}
   3.237 +      }
   3.238 +      data.pop_back();
   3.239 +    }
   3.240 +
   3.241 +    
   3.242 +    /// \brief Returns the priority of \c i.
   3.243 +    ///
   3.244 +    /// This function returns the priority of item \c i.  
   3.245 +    /// \pre \c i must be in the heap.
   3.246 +    /// \param i The item.
   3.247 +    Prio operator[](const Item &i) const {
   3.248 +      int idx = iim[i];
   3.249 +      return data[idx].second;
   3.250 +    }
   3.251 +
   3.252 +    /// \brief \c i gets to the heap with priority \c p independently 
   3.253 +    /// if \c i was already there.
   3.254 +    ///
   3.255 +    /// This method calls \ref push(\c i, \c p) if \c i is not stored
   3.256 +    /// in the heap and sets the priority of \c i to \c p otherwise.
   3.257 +    /// \param i The item.
   3.258 +    /// \param p The priority.
   3.259 +    void set(const Item &i, const Prio &p) {
   3.260 +      int idx = iim[i];
   3.261 +      if( idx < 0 ) {
   3.262 +	push(i,p);
   3.263 +      }
   3.264 +      else if( comp(p, data[idx].second) ) {
   3.265 +	bubble_up(idx, Pair(i,p));
   3.266 +      }
   3.267 +      else {
   3.268 +	bubble_down(idx, Pair(i,p), data.size());
   3.269 +      }
   3.270 +    }
   3.271 +
   3.272 +    /// \brief Decreases the priority of \c i to \c p.
   3.273 +    ///
   3.274 +    /// This method decreases the priority of item \c i to \c p.
   3.275 +    /// \pre \c i must be stored in the heap with priority at least \c
   3.276 +    /// p relative to \c Compare.
   3.277 +    /// \param i The item.
   3.278 +    /// \param p The priority.
   3.279 +    void decrease(const Item &i, const Prio &p) {
   3.280 +      int idx = iim[i];
   3.281 +      bubble_up(idx, Pair(i,p));
   3.282 +    }
   3.283 +    
   3.284 +    /// \brief Increases the priority of \c i to \c p.
   3.285 +    ///
   3.286 +    /// This method sets the priority of item \c i to \c p. 
   3.287 +    /// \pre \c i must be stored in the heap with priority at most \c
   3.288 +    /// p relative to \c Compare.
   3.289 +    /// \param i The item.
   3.290 +    /// \param p The priority.
   3.291 +    void increase(const Item &i, const Prio &p) {
   3.292 +      int idx = iim[i];
   3.293 +      bubble_down(idx, Pair(i,p), data.size());
   3.294 +    }
   3.295 +
   3.296 +    /// \brief Returns if \c item is in, has already been in, or has 
   3.297 +    /// never been in the heap.
   3.298 +    ///
   3.299 +    /// This method returns PRE_HEAP if \c item has never been in the
   3.300 +    /// heap, IN_HEAP if it is in the heap at the moment, and POST_HEAP
   3.301 +    /// otherwise. In the latter case it is possible that \c item will
   3.302 +    /// get back to the heap again.
   3.303 +    /// \param i The item.
   3.304 +    State state(const Item &i) const {
   3.305 +      int s = iim[i];
   3.306 +      if( s>=0 )
   3.307 +	s=0;
   3.308 +      return State(s);
   3.309 +    }
   3.310 +
   3.311 +    /// \brief Sets the state of the \c item in the heap.
   3.312 +    ///
   3.313 +    /// Sets the state of the \c item in the heap. It can be used to
   3.314 +    /// manually clear the heap when it is important to achive the
   3.315 +    /// better time complexity.
   3.316 +    /// \param i The item.
   3.317 +    /// \param st The state. It should not be \c IN_HEAP. 
   3.318 +    void state(const Item& i, State st) {
   3.319 +      switch (st) {
   3.320 +      case POST_HEAP:
   3.321 +      case PRE_HEAP:
   3.322 +        if (state(i) == IN_HEAP) {
   3.323 +          erase(i);
   3.324 +        }
   3.325 +        iim[i] = st;
   3.326 +        break;
   3.327 +      case IN_HEAP:
   3.328 +        break;
   3.329 +      }
   3.330 +    }
   3.331 +
   3.332 +    /// \brief Replaces an item in the heap.
   3.333 +    ///
   3.334 +    /// The \c i item is replaced with \c j item. The \c i item should
   3.335 +    /// be in the heap, while the \c j should be out of the heap. The
   3.336 +    /// \c i item will out of the heap and \c j will be in the heap
   3.337 +    /// with the same prioriority as prevoiusly the \c i item.
   3.338 +    void replace(const Item& i, const Item& j) {
   3.339 +      int idx = iim[i];
   3.340 +      iim.set(i, iim[j]);
   3.341 +      iim.set(j, idx);
   3.342 +      data[idx].first = j;
   3.343 +    }
   3.344 +
   3.345 +  }; // class BinHeap
   3.346 +  
   3.347 +} // namespace lemon
   3.348 +
   3.349 +#endif // LEMON_BIN_HEAP_H
     4.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
     4.2 +++ b/lemon/bits/path_dump.h	Thu Feb 07 21:37:07 2008 +0000
     4.3 @@ -0,0 +1,174 @@
     4.4 +/* -*- C++ -*-
     4.5 + *
     4.6 + * This file is a part of LEMON, a generic C++ optimization library
     4.7 + *
     4.8 + * Copyright (C) 2003-2008
     4.9 + * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
    4.10 + * (Egervary Research Group on Combinatorial Optimization, EGRES).
    4.11 + *
    4.12 + * Permission to use, modify and distribute this software is granted
    4.13 + * provided that this copyright notice appears in all copies. For
    4.14 + * precise terms see the accompanying LICENSE file.
    4.15 + *
    4.16 + * This software is provided "AS IS" with no warranty of any kind,
    4.17 + * express or implied, and with no claim as to its suitability for any
    4.18 + * purpose.
    4.19 + *
    4.20 + */
    4.21 +
    4.22 +#ifndef LEMON_BITS_PRED_MAP_PATH_H
    4.23 +#define LEMON_BITS_PRED_MAP_PATH_H
    4.24 +
    4.25 +namespace lemon {
    4.26 +
    4.27 +  template <typename _Digraph, typename _PredMap>
    4.28 +  class PredMapPath {
    4.29 +  public:
    4.30 +    typedef True RevPathTag;
    4.31 +
    4.32 +    typedef _Digraph Digraph;
    4.33 +    typedef typename Digraph::Arc Arc;
    4.34 +    typedef _PredMap PredMap;
    4.35 +
    4.36 +    PredMapPath(const Digraph& _digraph, const PredMap& _predMap,
    4.37 +                typename Digraph::Node _target)
    4.38 +      : digraph(_digraph), predMap(_predMap), target(_target) {}
    4.39 +
    4.40 +    int length() const {
    4.41 +      int len = 0;
    4.42 +      typename Digraph::Node node = target;
    4.43 +      typename Digraph::Arc arc;
    4.44 +      while ((arc = predMap[node]) != INVALID) {
    4.45 +        node = digraph.source(arc);
    4.46 +        ++len;
    4.47 +      }
    4.48 +      return len;
    4.49 +    }
    4.50 +
    4.51 +    bool empty() const {
    4.52 +      return predMap[target] != INVALID;
    4.53 +    }
    4.54 +
    4.55 +    class RevArcIt {
    4.56 +    public:
    4.57 +      RevArcIt() {}
    4.58 +      RevArcIt(Invalid) : path(0), current(INVALID) {}
    4.59 +      RevArcIt(const PredMapPath& _path) 
    4.60 +        : path(&_path), current(_path.target) {
    4.61 +        if (path->predMap[current] == INVALID) current = INVALID;
    4.62 +      }
    4.63 +
    4.64 +      operator const typename Digraph::Arc() const {
    4.65 +        return path->predMap[current];
    4.66 +      }
    4.67 +
    4.68 +      RevArcIt& operator++() {
    4.69 +        current = path->digraph.source(path->predMap[current]);
    4.70 +        if (path->predMap[current] == INVALID) current = INVALID;
    4.71 +        return *this;
    4.72 +      }
    4.73 +
    4.74 +      bool operator==(const RevArcIt& e) const { 
    4.75 +        return current == e.current; 
    4.76 +      }
    4.77 +
    4.78 +      bool operator!=(const RevArcIt& e) const {
    4.79 +        return current != e.current; 
    4.80 +      }
    4.81 +
    4.82 +      bool operator<(const RevArcIt& e) const { 
    4.83 +        return current < e.current; 
    4.84 +      }
    4.85 +      
    4.86 +    private:
    4.87 +      const PredMapPath* path;
    4.88 +      typename Digraph::Node current;
    4.89 +    };
    4.90 +
    4.91 +  private:
    4.92 +    const Digraph& digraph;
    4.93 +    const PredMap& predMap;
    4.94 +    typename Digraph::Node target;
    4.95 +  };
    4.96 +
    4.97 +
    4.98 +  template <typename _Digraph, typename _PredMatrixMap>
    4.99 +  class PredMatrixMapPath {
   4.100 +  public:
   4.101 +    typedef True RevPathTag;
   4.102 +
   4.103 +    typedef _Digraph Digraph;
   4.104 +    typedef typename Digraph::Arc Arc;
   4.105 +    typedef _PredMatrixMap PredMatrixMap;
   4.106 +
   4.107 +    PredMatrixMapPath(const Digraph& _digraph, 
   4.108 +                      const PredMatrixMap& _predMatrixMap,
   4.109 +                      typename Digraph::Node _source, 
   4.110 +                      typename Digraph::Node _target)
   4.111 +      : digraph(_digraph), predMatrixMap(_predMatrixMap), 
   4.112 +        source(_source), target(_target) {}
   4.113 +
   4.114 +    int length() const {
   4.115 +      int len = 0;
   4.116 +      typename Digraph::Node node = target;
   4.117 +      typename Digraph::Arc arc;
   4.118 +      while ((arc = predMatrixMap(source, node)) != INVALID) {
   4.119 +        node = digraph.source(arc);
   4.120 +        ++len;
   4.121 +      }
   4.122 +      return len;
   4.123 +    }
   4.124 +
   4.125 +    bool empty() const {
   4.126 +      return source != target;
   4.127 +    }
   4.128 +
   4.129 +    class RevArcIt {
   4.130 +    public:
   4.131 +      RevArcIt() {}
   4.132 +      RevArcIt(Invalid) : path(0), current(INVALID) {}
   4.133 +      RevArcIt(const PredMatrixMapPath& _path) 
   4.134 +        : path(&_path), current(_path.target) {
   4.135 +        if (path->predMatrixMap(path->source, current) == INVALID) 
   4.136 +          current = INVALID;
   4.137 +      }
   4.138 +
   4.139 +      operator const typename Digraph::Arc() const {
   4.140 +        return path->predMatrixMap(path->source, current);
   4.141 +      }
   4.142 +
   4.143 +      RevArcIt& operator++() {
   4.144 +        current = 
   4.145 +          path->digraph.source(path->predMatrixMap(path->source, current));
   4.146 +        if (path->predMatrixMap(path->source, current) == INVALID) 
   4.147 +          current = INVALID;
   4.148 +        return *this;
   4.149 +      }
   4.150 +
   4.151 +      bool operator==(const RevArcIt& e) const { 
   4.152 +        return current == e.current; 
   4.153 +      }
   4.154 +
   4.155 +      bool operator!=(const RevArcIt& e) const {
   4.156 +        return current != e.current; 
   4.157 +      }
   4.158 +
   4.159 +      bool operator<(const RevArcIt& e) const { 
   4.160 +        return current < e.current; 
   4.161 +      }
   4.162 +      
   4.163 +    private:
   4.164 +      const PredMatrixMapPath* path;
   4.165 +      typename Digraph::Node current;
   4.166 +    };
   4.167 +
   4.168 +  private:
   4.169 +    const Digraph& digraph;
   4.170 +    const PredMatrixMap& predMatrixMap;
   4.171 +    typename Digraph::Node source;
   4.172 +    typename Digraph::Node target;
   4.173 +  };
   4.174 +
   4.175 +}
   4.176 +
   4.177 +#endif
     5.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
     5.2 +++ b/lemon/concepts/heap.h	Thu Feb 07 21:37:07 2008 +0000
     5.3 @@ -0,0 +1,226 @@
     5.4 +/* -*- C++ -*-
     5.5 + *
     5.6 + * This file is a part of LEMON, a generic C++ optimization library
     5.7 + *
     5.8 + * Copyright (C) 2003-2008
     5.9 + * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
    5.10 + * (Egervary Research Group on Combinatorial Optimization, EGRES).
    5.11 + *
    5.12 + * Permission to use, modify and distribute this software is granted
    5.13 + * provided that this copyright notice appears in all copies. For
    5.14 + * precise terms see the accompanying LICENSE file.
    5.15 + *
    5.16 + * This software is provided "AS IS" with no warranty of any kind,
    5.17 + * express or implied, and with no claim as to its suitability for any
    5.18 + * purpose.
    5.19 + *
    5.20 + */
    5.21 +
    5.22 +///\ingroup concept
    5.23 +///\file
    5.24 +///\brief Classes for representing heaps.
    5.25 +///
    5.26 +
    5.27 +#ifndef LEMON_CONCEPT_HEAP_H
    5.28 +#define LEMON_CONCEPT_HEAP_H
    5.29 +
    5.30 +#include <lemon/bits/invalid.h>
    5.31 +
    5.32 +namespace lemon {
    5.33 +  namespace concepts {
    5.34 +    /// \addtogroup concept
    5.35 +    /// @{
    5.36 +
    5.37 +
    5.38 +    /// \brief A concept structure describes the main interface of heaps.
    5.39 +    ///
    5.40 +    /// A concept structure describes the main interface of heaps.
    5.41 +    ///
    5.42 +    template <typename Prio, typename ItemIntMap>
    5.43 +    class Heap {
    5.44 +    public:
    5.45 +
    5.46 +      ///\brief Type of the items stored in the heap.
    5.47 +      typedef typename ItemIntMap::Key  Item;
    5.48 +  
    5.49 +
    5.50 +      /// \brief Type to represent the items states.
    5.51 +      ///
    5.52 +      /// Each Item element have a state associated to it. It may be "in heap",
    5.53 +      /// "pre heap" or "post heap". The later two are indifferent from the
    5.54 +      /// heap's point of view, but may be useful to the user.
    5.55 +      ///
    5.56 +      /// The ItemIntMap _should_ be initialized in such way, that it maps
    5.57 +      /// PRE_HEAP (-1) to any element to be put in the heap...
    5.58 +      enum State {
    5.59 +	IN_HEAP = 0,
    5.60 +	PRE_HEAP = -1,
    5.61 +	POST_HEAP = -2
    5.62 +      };
    5.63 +      
    5.64 +      /// \brief The constructor.
    5.65 +      ///
    5.66 +      /// The constructor.
    5.67 +      /// \param _iim should be given to the constructor, since it is used
    5.68 +      /// internally to handle the cross references. The value of the map
    5.69 +      /// should be PRE_HEAP (-1) for each element.
    5.70 +      explicit Heap(ItemIntMap &_iim) {}
    5.71 +
    5.72 +      /// \brief The number of items stored in the heap.
    5.73 +      ///
    5.74 +      /// Returns the number of items stored in the heap.
    5.75 +      int size() const { return 0; }
    5.76 +
    5.77 +      /// \brief Checks if the heap stores no items.
    5.78 +      ///
    5.79 +      /// Returns \c true if and only if the heap stores no items.
    5.80 +      bool empty() const { return false; }
    5.81 +
    5.82 +      /// \brief Makes empty this heap.
    5.83 +      ///
    5.84 +      /// Makes this heap empty.
    5.85 +      void clear();
    5.86 +
    5.87 +      /// \brief Insert an item into the heap with the given heap.
    5.88 +      ///    
    5.89 +      /// Adds \c i to the heap with priority \c p. 
    5.90 +      /// \param i The item to insert.
    5.91 +      /// \param p The priority of the item.
    5.92 +      void push(const Item &i, const Prio &p) {}
    5.93 +
    5.94 +      /// \brief Returns the item with minimum priority.
    5.95 +      ///
    5.96 +      /// This method returns the item with minimum priority.  
    5.97 +      /// \pre The heap must be nonempty.  
    5.98 +      Item top() const {}
    5.99 +
   5.100 +      /// \brief Returns the minimum priority.
   5.101 +      ///
   5.102 +      /// It returns the minimum priority.
   5.103 +      /// \pre The heap must be nonempty.
   5.104 +      Prio prio() const {}
   5.105 +
   5.106 +      /// \brief Deletes the item with minimum priority.
   5.107 +      ///
   5.108 +      /// This method deletes the item with minimum priority.
   5.109 +      /// \pre The heap must be non-empty.  
   5.110 +      void pop() {}
   5.111 +
   5.112 +      /// \brief Deletes \c i from the heap.
   5.113 +      ///
   5.114 +      /// This method deletes item \c i from the heap, if \c i was
   5.115 +      /// already stored in the heap.
   5.116 +      /// \param i The item to erase. 
   5.117 +      void erase(const Item &i) {}
   5.118 +
   5.119 +      /// \brief Returns the priority of \c i.
   5.120 +      ///
   5.121 +      /// This function returns the priority of item \c i.  
   5.122 +      /// \pre \c i must be in the heap.
   5.123 +      /// \param i The item.
   5.124 +      Prio operator[](const Item &i) const {}
   5.125 +
   5.126 +      /// \brief \c i gets to the heap with priority \c p independently 
   5.127 +      /// if \c i was already there.
   5.128 +      ///
   5.129 +      /// This method calls \ref push(\c i, \c p) if \c i is not stored
   5.130 +      /// in the heap and sets the priority of \c i to \c p otherwise.
   5.131 +      /// It may throw an \e UnderFlowPriorityException. 
   5.132 +      /// \param i The item.
   5.133 +      /// \param p The priority.
   5.134 +      void set(const Item &i, const Prio &p) {}
   5.135 +      
   5.136 +      /// \brief Decreases the priority of \c i to \c p.
   5.137 +      ///
   5.138 +      /// This method decreases the priority of item \c i to \c p.
   5.139 +      /// \pre \c i must be stored in the heap with priority at least \c p.
   5.140 +      /// \param i The item.
   5.141 +      /// \param p The priority.
   5.142 +      void decrease(const Item &i, const Prio &p) {}
   5.143 +
   5.144 +      /// \brief Increases the priority of \c i to \c p.
   5.145 +      ///
   5.146 +      /// This method sets the priority of item \c i to \c p. 
   5.147 +      /// \pre \c i must be stored in the heap with priority at most \c
   5.148 +      /// p relative to \c Compare.
   5.149 +      /// \param i The item.
   5.150 +      /// \param p The priority.
   5.151 +      void increase(const Item &i, const Prio &p) {}
   5.152 +
   5.153 +      /// \brief Returns if \c item is in, has already been in, or has 
   5.154 +      /// never been in the heap.
   5.155 +      ///
   5.156 +      /// This method returns PRE_HEAP if \c item has never been in the
   5.157 +      /// heap, IN_HEAP if it is in the heap at the moment, and POST_HEAP
   5.158 +      /// otherwise. In the latter case it is possible that \c item will
   5.159 +      /// get back to the heap again.
   5.160 +      /// \param i The item.
   5.161 +      State state(const Item &i) const {}
   5.162 +
   5.163 +      /// \brief Sets the state of the \c item in the heap.
   5.164 +      ///
   5.165 +      /// Sets the state of the \c item in the heap. It can be used to
   5.166 +      /// manually clear the heap when it is important to achive the
   5.167 +      /// better time complexity.
   5.168 +      /// \param i The item.
   5.169 +      /// \param st The state. It should not be \c IN_HEAP. 
   5.170 +      void state(const Item& i, State st) {}
   5.171 +
   5.172 +
   5.173 +      template <typename _Heap>
   5.174 +      struct Constraints {
   5.175 +      public:
   5.176 +    
   5.177 +	void constraints() {
   5.178 +	  Item item;
   5.179 +	  Prio prio;
   5.180 +
   5.181 +	  item=Item();
   5.182 +	  prio=Prio();
   5.183 +
   5.184 +	  ignore_unused_variable_warning(item);
   5.185 +	  ignore_unused_variable_warning(prio);
   5.186 +
   5.187 +	  typedef typename _Heap::State State;
   5.188 +	  State state;
   5.189 +
   5.190 +	  ignore_unused_variable_warning(state);
   5.191 +      
   5.192 +	  _Heap heap1 = _Heap(map);
   5.193 +
   5.194 +	  ignore_unused_variable_warning(heap1);
   5.195 +      
   5.196 +	  heap.push(item, prio);
   5.197 +
   5.198 +	  prio = heap.prio();
   5.199 +	  item = heap.top();
   5.200 +
   5.201 +	  heap.pop();
   5.202 +
   5.203 +	  heap.set(item, prio);
   5.204 +	  heap.decrease(item, prio);
   5.205 +	  heap.increase(item, prio);
   5.206 +	  prio = heap[item];
   5.207 +
   5.208 +	  heap.erase(item);
   5.209 +
   5.210 +	  state = heap.state(item);
   5.211 +
   5.212 +	  state = _Heap::PRE_HEAP;
   5.213 +	  state = _Heap::IN_HEAP;
   5.214 +	  state = _Heap::POST_HEAP;
   5.215 +
   5.216 +	  heap.clear();
   5.217 +	}
   5.218 +    
   5.219 +	_Heap& heap;
   5.220 +	ItemIntMap& map;
   5.221 +
   5.222 +	Constraints() : heap(0), map(0) {}
   5.223 +      };
   5.224 +    };
   5.225 +
   5.226 +    /// @}
   5.227 +  } // namespace lemon
   5.228 +}
   5.229 +#endif // LEMON_CONCEPT_PATH_H
     6.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
     6.2 +++ b/lemon/dfs.h	Thu Feb 07 21:37:07 2008 +0000
     6.3 @@ -0,0 +1,1543 @@
     6.4 +/* -*- C++ -*-
     6.5 + *
     6.6 + * This file is a part of LEMON, a generic C++ optimization library
     6.7 + *
     6.8 + * Copyright (C) 2003-2008
     6.9 + * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
    6.10 + * (Egervary Research Group on Combinatorial Optimization, EGRES).
    6.11 + *
    6.12 + * Permission to use, modify and distribute this software is granted
    6.13 + * provided that this copyright notice appears in all copies. For
    6.14 + * precise terms see the accompanying LICENSE file.
    6.15 + *
    6.16 + * This software is provided "AS IS" with no warranty of any kind,
    6.17 + * express or implied, and with no claim as to its suitability for any
    6.18 + * purpose.
    6.19 + *
    6.20 + */
    6.21 +
    6.22 +#ifndef LEMON_DFS_H
    6.23 +#define LEMON_DFS_H
    6.24 +
    6.25 +///\ingroup search
    6.26 +///\file
    6.27 +///\brief Dfs algorithm.
    6.28 +
    6.29 +#include <lemon/list_graph.h>
    6.30 +#include <lemon/graph_utils.h>
    6.31 +#include <lemon/bits/path_dump.h>
    6.32 +#include <lemon/bits/invalid.h>
    6.33 +#include <lemon/error.h>
    6.34 +#include <lemon/maps.h>
    6.35 +
    6.36 +#include <lemon/concept_check.h>
    6.37 +
    6.38 +namespace lemon {
    6.39 +
    6.40 +  
    6.41 +  ///Default traits class of Dfs class.
    6.42 +
    6.43 +  ///Default traits class of Dfs class.
    6.44 +  ///\param GR Digraph type.
    6.45 +  template<class GR>
    6.46 +  struct DfsDefaultTraits
    6.47 +  {
    6.48 +    ///The digraph type the algorithm runs on. 
    6.49 +    typedef GR Digraph;
    6.50 +    ///\brief The type of the map that stores the last
    6.51 +    ///arcs of the %DFS paths.
    6.52 +    /// 
    6.53 +    ///The type of the map that stores the last
    6.54 +    ///arcs of the %DFS paths.
    6.55 +    ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
    6.56 +    ///
    6.57 +    typedef typename Digraph::template NodeMap<typename GR::Arc> PredMap;
    6.58 +    ///Instantiates a PredMap.
    6.59 + 
    6.60 +    ///This function instantiates a \ref PredMap. 
    6.61 +    ///\param G is the digraph, to which we would like to define the PredMap.
    6.62 +    ///\todo The digraph alone may be insufficient to initialize
    6.63 +    static PredMap *createPredMap(const GR &G) 
    6.64 +    {
    6.65 +      return new PredMap(G);
    6.66 +    }
    6.67 +
    6.68 +    ///The type of the map that indicates which nodes are processed.
    6.69 + 
    6.70 +    ///The type of the map that indicates which nodes are processed.
    6.71 +    ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
    6.72 +    ///\todo named parameter to set this type, function to read and write.
    6.73 +    typedef NullMap<typename Digraph::Node,bool> ProcessedMap;
    6.74 +    ///Instantiates a ProcessedMap.
    6.75 + 
    6.76 +    ///This function instantiates a \ref ProcessedMap. 
    6.77 +    ///\param g is the digraph, to which
    6.78 +    ///we would like to define the \ref ProcessedMap
    6.79 +#ifdef DOXYGEN
    6.80 +    static ProcessedMap *createProcessedMap(const GR &g)
    6.81 +#else
    6.82 +    static ProcessedMap *createProcessedMap(const GR &)
    6.83 +#endif
    6.84 +    {
    6.85 +      return new ProcessedMap();
    6.86 +    }
    6.87 +    ///The type of the map that indicates which nodes are reached.
    6.88 + 
    6.89 +    ///The type of the map that indicates which nodes are reached.
    6.90 +    ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
    6.91 +    ///\todo named parameter to set this type, function to read and write.
    6.92 +    typedef typename Digraph::template NodeMap<bool> ReachedMap;
    6.93 +    ///Instantiates a ReachedMap.
    6.94 + 
    6.95 +    ///This function instantiates a \ref ReachedMap. 
    6.96 +    ///\param G is the digraph, to which
    6.97 +    ///we would like to define the \ref ReachedMap.
    6.98 +    static ReachedMap *createReachedMap(const GR &G)
    6.99 +    {
   6.100 +      return new ReachedMap(G);
   6.101 +    }
   6.102 +    ///The type of the map that stores the dists of the nodes.
   6.103 + 
   6.104 +    ///The type of the map that stores the dists of the nodes.
   6.105 +    ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
   6.106 +    ///
   6.107 +    typedef typename Digraph::template NodeMap<int> DistMap;
   6.108 +    ///Instantiates a DistMap.
   6.109 + 
   6.110 +    ///This function instantiates a \ref DistMap. 
   6.111 +    ///\param G is the digraph, to which we would like to define the \ref DistMap
   6.112 +    static DistMap *createDistMap(const GR &G)
   6.113 +    {
   6.114 +      return new DistMap(G);
   6.115 +    }
   6.116 +  };
   6.117 +  
   6.118 +  ///%DFS algorithm class.
   6.119 +  
   6.120 +  ///\ingroup search
   6.121 +  ///This class provides an efficient implementation of the %DFS algorithm.
   6.122 +  ///
   6.123 +  ///\param GR The digraph type the algorithm runs on. The default value is
   6.124 +  ///\ref ListDigraph. The value of GR is not used directly by Dfs, it
   6.125 +  ///is only passed to \ref DfsDefaultTraits.
   6.126 +  ///\param TR Traits class to set various data types used by the algorithm.
   6.127 +  ///The default traits class is
   6.128 +  ///\ref DfsDefaultTraits "DfsDefaultTraits<GR>".
   6.129 +  ///See \ref DfsDefaultTraits for the documentation of
   6.130 +  ///a Dfs traits class.
   6.131 +  ///
   6.132 +  ///\author Jacint Szabo and Alpar Juttner
   6.133 +#ifdef DOXYGEN
   6.134 +  template <typename GR,
   6.135 +	    typename TR>
   6.136 +#else
   6.137 +  template <typename GR=ListDigraph,
   6.138 +	    typename TR=DfsDefaultTraits<GR> >
   6.139 +#endif
   6.140 +  class Dfs {
   6.141 +  public:
   6.142 +    /**
   6.143 +     * \brief \ref Exception for uninitialized parameters.
   6.144 +     *
   6.145 +     * This error represents problems in the initialization
   6.146 +     * of the parameters of the algorithms.
   6.147 +     */
   6.148 +    class UninitializedParameter : public lemon::UninitializedParameter {
   6.149 +    public:
   6.150 +      virtual const char* what() const throw() {
   6.151 +	return "lemon::Dfs::UninitializedParameter";
   6.152 +      }
   6.153 +    };
   6.154 +
   6.155 +    typedef TR Traits;
   6.156 +    ///The type of the underlying digraph.
   6.157 +    typedef typename TR::Digraph Digraph;
   6.158 +    ///\e
   6.159 +    typedef typename Digraph::Node Node;
   6.160 +    ///\e
   6.161 +    typedef typename Digraph::NodeIt NodeIt;
   6.162 +    ///\e
   6.163 +    typedef typename Digraph::Arc Arc;
   6.164 +    ///\e
   6.165 +    typedef typename Digraph::OutArcIt OutArcIt;
   6.166 +    
   6.167 +    ///\brief The type of the map that stores the last
   6.168 +    ///arcs of the %DFS paths.
   6.169 +    typedef typename TR::PredMap PredMap;
   6.170 +    ///The type of the map indicating which nodes are reached.
   6.171 +    typedef typename TR::ReachedMap ReachedMap;
   6.172 +    ///The type of the map indicating which nodes are processed.
   6.173 +    typedef typename TR::ProcessedMap ProcessedMap;
   6.174 +    ///The type of the map that stores the dists of the nodes.
   6.175 +    typedef typename TR::DistMap DistMap;
   6.176 +  private:
   6.177 +    /// Pointer to the underlying digraph.
   6.178 +    const Digraph *G;
   6.179 +    ///Pointer to the map of predecessors arcs.
   6.180 +    PredMap *_pred;
   6.181 +    ///Indicates if \ref _pred is locally allocated (\c true) or not.
   6.182 +    bool local_pred;
   6.183 +    ///Pointer to the map of distances.
   6.184 +    DistMap *_dist;
   6.185 +    ///Indicates if \ref _dist is locally allocated (\c true) or not.
   6.186 +    bool local_dist;
   6.187 +    ///Pointer to the map of reached status of the nodes.
   6.188 +    ReachedMap *_reached;
   6.189 +    ///Indicates if \ref _reached is locally allocated (\c true) or not.
   6.190 +    bool local_reached;
   6.191 +    ///Pointer to the map of processed status of the nodes.
   6.192 +    ProcessedMap *_processed;
   6.193 +    ///Indicates if \ref _processed is locally allocated (\c true) or not.
   6.194 +    bool local_processed;
   6.195 +
   6.196 +    std::vector<typename Digraph::OutArcIt> _stack;
   6.197 +    int _stack_head;
   6.198 +
   6.199 +    ///Creates the maps if necessary.
   6.200 +    
   6.201 +    ///\todo Better memory allocation (instead of new).
   6.202 +    void create_maps() 
   6.203 +    {
   6.204 +      if(!_pred) {
   6.205 +	local_pred = true;
   6.206 +	_pred = Traits::createPredMap(*G);
   6.207 +      }
   6.208 +      if(!_dist) {
   6.209 +	local_dist = true;
   6.210 +	_dist = Traits::createDistMap(*G);
   6.211 +      }
   6.212 +      if(!_reached) {
   6.213 +	local_reached = true;
   6.214 +	_reached = Traits::createReachedMap(*G);
   6.215 +      }
   6.216 +      if(!_processed) {
   6.217 +	local_processed = true;
   6.218 +	_processed = Traits::createProcessedMap(*G);
   6.219 +      }
   6.220 +    }
   6.221 +
   6.222 +  protected:
   6.223 +
   6.224 +    Dfs() {}
   6.225 +    
   6.226 +  public:
   6.227 +
   6.228 +    typedef Dfs Create;
   6.229 +
   6.230 +    ///\name Named template parameters
   6.231 +
   6.232 +    ///@{
   6.233 +
   6.234 +    template <class T>
   6.235 +    struct DefPredMapTraits : public Traits {
   6.236 +      typedef T PredMap;
   6.237 +      static PredMap *createPredMap(const Digraph &G) 
   6.238 +      {
   6.239 +	throw UninitializedParameter();
   6.240 +      }
   6.241 +    };
   6.242 +    ///\brief \ref named-templ-param "Named parameter" for setting
   6.243 +    ///PredMap type
   6.244 +    ///
   6.245 +    ///\ref named-templ-param "Named parameter" for setting PredMap type
   6.246 +    ///
   6.247 +    template <class T>
   6.248 +    struct DefPredMap : public Dfs<Digraph, DefPredMapTraits<T> > {
   6.249 +      typedef Dfs<Digraph, DefPredMapTraits<T> > Create;
   6.250 +    };
   6.251 +    
   6.252 +    
   6.253 +    template <class T>
   6.254 +    struct DefDistMapTraits : public Traits {
   6.255 +      typedef T DistMap;
   6.256 +      static DistMap *createDistMap(const Digraph &) 
   6.257 +      {
   6.258 +	throw UninitializedParameter();
   6.259 +      }
   6.260 +    };
   6.261 +    ///\brief \ref named-templ-param "Named parameter" for setting
   6.262 +    ///DistMap type
   6.263 +    ///
   6.264 +    ///\ref named-templ-param "Named parameter" for setting DistMap
   6.265 +    ///type
   6.266 +    template <class T>
   6.267 +    struct DefDistMap {
   6.268 +      typedef Dfs<Digraph, DefDistMapTraits<T> > Create;
   6.269 +    };
   6.270 +    
   6.271 +    template <class T>
   6.272 +    struct DefReachedMapTraits : public Traits {
   6.273 +      typedef T ReachedMap;
   6.274 +      static ReachedMap *createReachedMap(const Digraph &) 
   6.275 +      {
   6.276 +	throw UninitializedParameter();
   6.277 +      }
   6.278 +    };
   6.279 +    ///\brief \ref named-templ-param "Named parameter" for setting
   6.280 +    ///ReachedMap type
   6.281 +    ///
   6.282 +    ///\ref named-templ-param "Named parameter" for setting ReachedMap type
   6.283 +    ///
   6.284 +    template <class T>
   6.285 +    struct DefReachedMap : public Dfs< Digraph, DefReachedMapTraits<T> > {
   6.286 +      typedef Dfs< Digraph, DefReachedMapTraits<T> > Create;
   6.287 +    };
   6.288 +
   6.289 +    template <class T>
   6.290 +    struct DefProcessedMapTraits : public Traits {
   6.291 +      typedef T ProcessedMap;
   6.292 +      static ProcessedMap *createProcessedMap(const Digraph &) 
   6.293 +      {
   6.294 +	throw UninitializedParameter();
   6.295 +      }
   6.296 +    };
   6.297 +    ///\brief \ref named-templ-param "Named parameter" for setting
   6.298 +    ///ProcessedMap type
   6.299 +    ///
   6.300 +    ///\ref named-templ-param "Named parameter" for setting ProcessedMap type
   6.301 +    ///
   6.302 +    template <class T>
   6.303 +    struct DefProcessedMap : public Dfs< Digraph, DefProcessedMapTraits<T> > { 
   6.304 +      typedef Dfs< Digraph, DefProcessedMapTraits<T> > Create;
   6.305 +    };
   6.306 +    
   6.307 +    struct DefDigraphProcessedMapTraits : public Traits {
   6.308 +      typedef typename Digraph::template NodeMap<bool> ProcessedMap;
   6.309 +      static ProcessedMap *createProcessedMap(const Digraph &G) 
   6.310 +      {
   6.311 +	return new ProcessedMap(G);
   6.312 +      }
   6.313 +    };
   6.314 +    ///\brief \ref named-templ-param "Named parameter"
   6.315 +    ///for setting the ProcessedMap type to be Digraph::NodeMap<bool>.
   6.316 +    ///
   6.317 +    ///\ref named-templ-param "Named parameter"
   6.318 +    ///for setting the ProcessedMap type to be Digraph::NodeMap<bool>.
   6.319 +    ///If you don't set it explicitely, it will be automatically allocated.
   6.320 +    template <class T>
   6.321 +    class DefProcessedMapToBeDefaultMap :
   6.322 +      public Dfs< Digraph, DefDigraphProcessedMapTraits> { 
   6.323 +      typedef Dfs< Digraph, DefDigraphProcessedMapTraits> Create;
   6.324 +    };
   6.325 +    
   6.326 +    ///@}
   6.327 +
   6.328 +  public:      
   6.329 +    
   6.330 +    ///Constructor.
   6.331 +    
   6.332 +    ///\param _G the digraph the algorithm will run on.
   6.333 +    ///
   6.334 +    Dfs(const Digraph& _G) :
   6.335 +      G(&_G),
   6.336 +      _pred(NULL), local_pred(false),
   6.337 +      _dist(NULL), local_dist(false),
   6.338 +      _reached(NULL), local_reached(false),
   6.339 +      _processed(NULL), local_processed(false)
   6.340 +    { }
   6.341 +    
   6.342 +    ///Destructor.
   6.343 +    ~Dfs() 
   6.344 +    {
   6.345 +      if(local_pred) delete _pred;
   6.346 +      if(local_dist) delete _dist;
   6.347 +      if(local_reached) delete _reached;
   6.348 +      if(local_processed) delete _processed;
   6.349 +    }
   6.350 +
   6.351 +    ///Sets the map storing the predecessor arcs.
   6.352 +
   6.353 +    ///Sets the map storing the predecessor arcs.
   6.354 +    ///If you don't use this function before calling \ref run(),
   6.355 +    ///it will allocate one. The destuctor deallocates this
   6.356 +    ///automatically allocated map, of course.
   6.357 +    ///\return <tt> (*this) </tt>
   6.358 +    Dfs &predMap(PredMap &m) 
   6.359 +    {
   6.360 +      if(local_pred) {
   6.361 +	delete _pred;
   6.362 +	local_pred=false;
   6.363 +      }
   6.364 +      _pred = &m;
   6.365 +      return *this;
   6.366 +    }
   6.367 +
   6.368 +    ///Sets the map storing the distances calculated by the algorithm.
   6.369 +
   6.370 +    ///Sets the map storing the distances calculated by the algorithm.
   6.371 +    ///If you don't use this function before calling \ref run(),
   6.372 +    ///it will allocate one. The destuctor deallocates this
   6.373 +    ///automatically allocated map, of course.
   6.374 +    ///\return <tt> (*this) </tt>
   6.375 +    Dfs &distMap(DistMap &m) 
   6.376 +    {
   6.377 +      if(local_dist) {
   6.378 +	delete _dist;
   6.379 +	local_dist=false;
   6.380 +      }
   6.381 +      _dist = &m;
   6.382 +      return *this;
   6.383 +    }
   6.384 +
   6.385 +    ///Sets the map indicating if a node is reached.
   6.386 +
   6.387 +    ///Sets the map indicating if a node is reached.
   6.388 +    ///If you don't use this function before calling \ref run(),
   6.389 +    ///it will allocate one. The destuctor deallocates this
   6.390 +    ///automatically allocated map, of course.
   6.391 +    ///\return <tt> (*this) </tt>
   6.392 +    Dfs &reachedMap(ReachedMap &m) 
   6.393 +    {
   6.394 +      if(local_reached) {
   6.395 +	delete _reached;
   6.396 +	local_reached=false;
   6.397 +      }
   6.398 +      _reached = &m;
   6.399 +      return *this;
   6.400 +    }
   6.401 +
   6.402 +    ///Sets the map indicating if a node is processed.
   6.403 +
   6.404 +    ///Sets the map indicating if a node is processed.
   6.405 +    ///If you don't use this function before calling \ref run(),
   6.406 +    ///it will allocate one. The destuctor deallocates this
   6.407 +    ///automatically allocated map, of course.
   6.408 +    ///\return <tt> (*this) </tt>
   6.409 +    Dfs &processedMap(ProcessedMap &m) 
   6.410 +    {
   6.411 +      if(local_processed) {
   6.412 +	delete _processed;
   6.413 +	local_processed=false;
   6.414 +      }
   6.415 +      _processed = &m;
   6.416 +      return *this;
   6.417 +    }
   6.418 +
   6.419 +  public:
   6.420 +    ///\name Execution control
   6.421 +    ///The simplest way to execute the algorithm is to use
   6.422 +    ///one of the member functions called \c run(...).
   6.423 +    ///\n
   6.424 +    ///If you need more control on the execution,
   6.425 +    ///first you must call \ref init(), then you can add a source node
   6.426 +    ///with \ref addSource().
   6.427 +    ///Finally \ref start() will perform the actual path
   6.428 +    ///computation.
   6.429 +
   6.430 +    ///@{
   6.431 +
   6.432 +    ///Initializes the internal data structures.
   6.433 +
   6.434 +    ///Initializes the internal data structures.
   6.435 +    ///
   6.436 +    void init()
   6.437 +    {
   6.438 +      create_maps();
   6.439 +      _stack.resize(countNodes(*G));
   6.440 +      _stack_head=-1;
   6.441 +      for ( NodeIt u(*G) ; u!=INVALID ; ++u ) {
   6.442 +	_pred->set(u,INVALID);
   6.443 +	// _predNode->set(u,INVALID);
   6.444 +	_reached->set(u,false);
   6.445 +	_processed->set(u,false);
   6.446 +      }
   6.447 +    }
   6.448 +    
   6.449 +    ///Adds a new source node.
   6.450 +
   6.451 +    ///Adds a new source node to the set of nodes to be processed.
   6.452 +    ///
   6.453 +    ///\warning dists are wrong (or at least strange)
   6.454 +    ///in case of multiple sources.
   6.455 +    void addSource(Node s)
   6.456 +    {
   6.457 +      if(!(*_reached)[s])
   6.458 +	{
   6.459 +	  _reached->set(s,true);
   6.460 +	  _pred->set(s,INVALID);
   6.461 +	  OutArcIt e(*G,s);
   6.462 +	  if(e!=INVALID) {
   6.463 +	    _stack[++_stack_head]=e;
   6.464 +	    _dist->set(s,_stack_head);
   6.465 +	  }
   6.466 +	  else {
   6.467 +	    _processed->set(s,true);
   6.468 +	    _dist->set(s,0);
   6.469 +	  }
   6.470 +	}
   6.471 +    }
   6.472 +    
   6.473 +    ///Processes the next arc.
   6.474 +
   6.475 +    ///Processes the next arc.
   6.476 +    ///
   6.477 +    ///\return The processed arc.
   6.478 +    ///
   6.479 +    ///\pre The stack must not be empty!
   6.480 +    Arc processNextArc()
   6.481 +    { 
   6.482 +      Node m;
   6.483 +      Arc e=_stack[_stack_head];
   6.484 +      if(!(*_reached)[m=G->target(e)]) {
   6.485 +	_pred->set(m,e);
   6.486 +	_reached->set(m,true);
   6.487 +	++_stack_head;
   6.488 +	_stack[_stack_head] = OutArcIt(*G, m);
   6.489 +	_dist->set(m,_stack_head);
   6.490 +      }
   6.491 +      else {
   6.492 +	m=G->source(e);
   6.493 +	++_stack[_stack_head];
   6.494 +      }
   6.495 +      while(_stack_head>=0 && _stack[_stack_head]==INVALID) {
   6.496 +	_processed->set(m,true);
   6.497 +	--_stack_head;
   6.498 +	if(_stack_head>=0) {
   6.499 +	  m=G->source(_stack[_stack_head]);
   6.500 +	  ++_stack[_stack_head];
   6.501 +	}
   6.502 +      }
   6.503 +      return e;
   6.504 +    }
   6.505 +    ///Next arc to be processed.
   6.506 +
   6.507 +    ///Next arc to be processed.
   6.508 +    ///
   6.509 +    ///\return The next arc to be processed or INVALID if the stack is
   6.510 +    /// empty.
   6.511 +    OutArcIt nextArc()
   6.512 +    { 
   6.513 +      return _stack_head>=0?_stack[_stack_head]:INVALID;
   6.514 +    }
   6.515 +
   6.516 +    ///\brief Returns \c false if there are nodes
   6.517 +    ///to be processed in the queue
   6.518 +    ///
   6.519 +    ///Returns \c false if there are nodes
   6.520 +    ///to be processed in the queue
   6.521 +    bool emptyQueue() { return _stack_head<0; }
   6.522 +    ///Returns the number of the nodes to be processed.
   6.523 +    
   6.524 +    ///Returns the number of the nodes to be processed in the queue.
   6.525 +    int queueSize() { return _stack_head+1; }
   6.526 +    
   6.527 +    ///Executes the algorithm.
   6.528 +
   6.529 +    ///Executes the algorithm.
   6.530 +    ///
   6.531 +    ///\pre init() must be called and at least one node should be added
   6.532 +    ///with addSource() before using this function.
   6.533 +    ///
   6.534 +    ///This method runs the %DFS algorithm from the root node(s)
   6.535 +    ///in order to
   6.536 +    ///compute the
   6.537 +    ///%DFS path to each node. The algorithm computes
   6.538 +    ///- The %DFS tree.
   6.539 +    ///- The distance of each node from the root(s) in the %DFS tree.
   6.540 +    ///
   6.541 +    void start()
   6.542 +    {
   6.543 +      while ( !emptyQueue() ) processNextArc();
   6.544 +    }
   6.545 +    
   6.546 +    ///Executes the algorithm until \c dest is reached.
   6.547 +
   6.548 +    ///Executes the algorithm until \c dest is reached.
   6.549 +    ///
   6.550 +    ///\pre init() must be called and at least one node should be added
   6.551 +    ///with addSource() before using this function.
   6.552 +    ///
   6.553 +    ///This method runs the %DFS algorithm from the root node(s)
   6.554 +    ///in order to
   6.555 +    ///compute the
   6.556 +    ///%DFS path to \c dest. The algorithm computes
   6.557 +    ///- The %DFS path to \c  dest.
   6.558 +    ///- The distance of \c dest from the root(s) in the %DFS tree.
   6.559 +    ///
   6.560 +    void start(Node dest)
   6.561 +    {
   6.562 +      while ( !emptyQueue() && G->target(_stack[_stack_head])!=dest ) 
   6.563 +	processNextArc();
   6.564 +    }
   6.565 +    
   6.566 +    ///Executes the algorithm until a condition is met.
   6.567 +
   6.568 +    ///Executes the algorithm until a condition is met.
   6.569 +    ///
   6.570 +    ///\pre init() must be called and at least one node should be added
   6.571 +    ///with addSource() before using this function.
   6.572 +    ///
   6.573 +    ///\param em must be a bool (or convertible) arc map. The algorithm
   6.574 +    ///will stop when it reaches an arc \c e with <tt>em[e]</tt> true.
   6.575 +    ///
   6.576 +    ///\return The reached arc \c e with <tt>em[e]</tt> true or
   6.577 +    ///\c INVALID if no such arc was found.
   6.578 +    ///
   6.579 +    ///\warning Contrary to \ref Bfs and \ref Dijkstra, \c em is an arc map,
   6.580 +    ///not a node map.
   6.581 +    template<class EM>
   6.582 +    Arc start(const EM &em)
   6.583 +    {
   6.584 +      while ( !emptyQueue() && !em[_stack[_stack_head]] )
   6.585 +        processNextArc();
   6.586 +      return emptyQueue() ? INVALID : _stack[_stack_head];
   6.587 +    }
   6.588 +
   6.589 +    ///Runs %DFS algorithm to visit all nodes in the digraph.
   6.590 +    
   6.591 +    ///This method runs the %DFS algorithm in order to
   6.592 +    ///compute the
   6.593 +    ///%DFS path to each node. The algorithm computes
   6.594 +    ///- The %DFS tree.
   6.595 +    ///- The distance of each node from the root in the %DFS tree.
   6.596 +    ///
   6.597 +    ///\note d.run() is just a shortcut of the following code.
   6.598 +    ///\code
   6.599 +    ///  d.init();
   6.600 +    ///  for (NodeIt it(digraph); it != INVALID; ++it) {
   6.601 +    ///    if (!d.reached(it)) {
   6.602 +    ///      d.addSource(it);
   6.603 +    ///      d.start();
   6.604 +    ///    }
   6.605 +    ///  }
   6.606 +    ///\endcode
   6.607 +    void run() {
   6.608 +      init();
   6.609 +      for (NodeIt it(*G); it != INVALID; ++it) {
   6.610 +        if (!reached(it)) {
   6.611 +          addSource(it);
   6.612 +          start();
   6.613 +        }
   6.614 +      }
   6.615 +    }
   6.616 +
   6.617 +    ///Runs %DFS algorithm from node \c s.
   6.618 +    
   6.619 +    ///This method runs the %DFS algorithm from a root node \c s
   6.620 +    ///in order to
   6.621 +    ///compute the
   6.622 +    ///%DFS path to each node. The algorithm computes
   6.623 +    ///- The %DFS tree.
   6.624 +    ///- The distance of each node from the root in the %DFS tree.
   6.625 +    ///
   6.626 +    ///\note d.run(s) is just a shortcut of the following code.
   6.627 +    ///\code
   6.628 +    ///  d.init();
   6.629 +    ///  d.addSource(s);
   6.630 +    ///  d.start();
   6.631 +    ///\endcode
   6.632 +    void run(Node s) {
   6.633 +      init();
   6.634 +      addSource(s);
   6.635 +      start();
   6.636 +    }
   6.637 +    
   6.638 +    ///Finds the %DFS path between \c s and \c t.
   6.639 +    
   6.640 +    ///Finds the %DFS path between \c s and \c t.
   6.641 +    ///
   6.642 +    ///\return The length of the %DFS s---t path if there exists one,
   6.643 +    ///0 otherwise.
   6.644 +    ///\note Apart from the return value, d.run(s,t) is
   6.645 +    ///just a shortcut of the following code.
   6.646 +    ///\code
   6.647 +    ///  d.init();
   6.648 +    ///  d.addSource(s);
   6.649 +    ///  d.start(t);
   6.650 +    ///\endcode
   6.651 +    int run(Node s,Node t) {
   6.652 +      init();
   6.653 +      addSource(s);
   6.654 +      start(t);
   6.655 +      return reached(t)?_stack_head+1:0;
   6.656 +    }
   6.657 +    
   6.658 +    ///@}
   6.659 +
   6.660 +    ///\name Query Functions
   6.661 +    ///The result of the %DFS algorithm can be obtained using these
   6.662 +    ///functions.\n
   6.663 +    ///Before the use of these functions,
   6.664 +    ///either run() or start() must be called.
   6.665 +    
   6.666 +    ///@{
   6.667 +
   6.668 +    typedef PredMapPath<Digraph, PredMap> Path;
   6.669 +
   6.670 +    ///Gives back the shortest path.
   6.671 +    
   6.672 +    ///Gives back the shortest path.
   6.673 +    ///\pre The \c t should be reachable from the source.
   6.674 +    Path path(Node t) 
   6.675 +    {
   6.676 +      return Path(*G, *_pred, t);
   6.677 +    }
   6.678 +
   6.679 +    ///The distance of a node from the root(s).
   6.680 +
   6.681 +    ///Returns the distance of a node from the root(s).
   6.682 +    ///\pre \ref run() must be called before using this function.
   6.683 +    ///\warning If node \c v is unreachable from the root(s) then the return 
   6.684 +    ///value of this funcion is undefined.
   6.685 +    int dist(Node v) const { return (*_dist)[v]; }
   6.686 +
   6.687 +    ///Returns the 'previous arc' of the %DFS tree.
   6.688 +
   6.689 +    ///For a node \c v it returns the 'previous arc'
   6.690 +    ///of the %DFS path,
   6.691 +    ///i.e. it returns the last arc of a %DFS path from the root(s) to \c
   6.692 +    ///v. It is \ref INVALID
   6.693 +    ///if \c v is unreachable from the root(s) or \c v is a root. The
   6.694 +    ///%DFS tree used here is equal to the %DFS tree used in
   6.695 +    ///\ref predNode().
   6.696 +    ///\pre Either \ref run() or \ref start() must be called before using
   6.697 +    ///this function.
   6.698 +    Arc predArc(Node v) const { return (*_pred)[v];}
   6.699 +
   6.700 +    ///Returns the 'previous node' of the %DFS tree.
   6.701 +
   6.702 +    ///For a node \c v it returns the 'previous node'
   6.703 +    ///of the %DFS tree,
   6.704 +    ///i.e. it returns the last but one node from a %DFS path from the
   6.705 +    ///root(s) to \c v.
   6.706 +    ///It is INVALID if \c v is unreachable from the root(s) or
   6.707 +    ///if \c v itself a root.
   6.708 +    ///The %DFS tree used here is equal to the %DFS
   6.709 +    ///tree used in \ref predArc().
   6.710 +    ///\pre Either \ref run() or \ref start() must be called before
   6.711 +    ///using this function.
   6.712 +    Node predNode(Node v) const { return (*_pred)[v]==INVALID ? INVALID:
   6.713 +				  G->source((*_pred)[v]); }
   6.714 +    
   6.715 +    ///Returns a reference to the NodeMap of distances.
   6.716 +
   6.717 +    ///Returns a reference to the NodeMap of distances.
   6.718 +    ///\pre Either \ref run() or \ref init() must
   6.719 +    ///be called before using this function.
   6.720 +    const DistMap &distMap() const { return *_dist;}
   6.721 + 
   6.722 +    ///Returns a reference to the %DFS arc-tree map.
   6.723 +
   6.724 +    ///Returns a reference to the NodeMap of the arcs of the
   6.725 +    ///%DFS tree.
   6.726 +    ///\pre Either \ref run() or \ref init()
   6.727 +    ///must be called before using this function.
   6.728 +    const PredMap &predMap() const { return *_pred;}
   6.729 + 
   6.730 +    ///Checks if a node is reachable from the root.
   6.731 +
   6.732 +    ///Returns \c true if \c v is reachable from the root(s).
   6.733 +    ///\warning The source nodes are inditated as unreachable.
   6.734 +    ///\pre Either \ref run() or \ref start()
   6.735 +    ///must be called before using this function.
   6.736 +    ///
   6.737 +    bool reached(Node v) { return (*_reached)[v]; }
   6.738 +    
   6.739 +    ///@}
   6.740 +  };
   6.741 +
   6.742 +  ///Default traits class of Dfs function.
   6.743 +
   6.744 +  ///Default traits class of Dfs function.
   6.745 +  ///\param GR Digraph type.
   6.746 +  template<class GR>
   6.747 +  struct DfsWizardDefaultTraits
   6.748 +  {
   6.749 +    ///The digraph type the algorithm runs on. 
   6.750 +    typedef GR Digraph;
   6.751 +    ///\brief The type of the map that stores the last
   6.752 +    ///arcs of the %DFS paths.
   6.753 +    /// 
   6.754 +    ///The type of the map that stores the last
   6.755 +    ///arcs of the %DFS paths.
   6.756 +    ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
   6.757 +    ///
   6.758 +    typedef NullMap<typename Digraph::Node,typename GR::Arc> PredMap;
   6.759 +    ///Instantiates a PredMap.
   6.760 + 
   6.761 +    ///This function instantiates a \ref PredMap. 
   6.762 +    ///\param g is the digraph, to which we would like to define the PredMap.
   6.763 +    ///\todo The digraph alone may be insufficient to initialize
   6.764 +#ifdef DOXYGEN
   6.765 +    static PredMap *createPredMap(const GR &g) 
   6.766 +#else
   6.767 +    static PredMap *createPredMap(const GR &) 
   6.768 +#endif
   6.769 +    {
   6.770 +      return new PredMap();
   6.771 +    }
   6.772 +
   6.773 +    ///The type of the map that indicates which nodes are processed.
   6.774 + 
   6.775 +    ///The type of the map that indicates which nodes are processed.
   6.776 +    ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
   6.777 +    ///\todo named parameter to set this type, function to read and write.
   6.778 +    typedef NullMap<typename Digraph::Node,bool> ProcessedMap;
   6.779 +    ///Instantiates a ProcessedMap.
   6.780 + 
   6.781 +    ///This function instantiates a \ref ProcessedMap. 
   6.782 +    ///\param g is the digraph, to which
   6.783 +    ///we would like to define the \ref ProcessedMap
   6.784 +#ifdef DOXYGEN
   6.785 +    static ProcessedMap *createProcessedMap(const GR &g)
   6.786 +#else
   6.787 +    static ProcessedMap *createProcessedMap(const GR &)
   6.788 +#endif
   6.789 +    {
   6.790 +      return new ProcessedMap();
   6.791 +    }
   6.792 +    ///The type of the map that indicates which nodes are reached.
   6.793 + 
   6.794 +    ///The type of the map that indicates which nodes are reached.
   6.795 +    ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
   6.796 +    ///\todo named parameter to set this type, function to read and write.
   6.797 +    typedef typename Digraph::template NodeMap<bool> ReachedMap;
   6.798 +    ///Instantiates a ReachedMap.
   6.799 + 
   6.800 +    ///This function instantiates a \ref ReachedMap. 
   6.801 +    ///\param G is the digraph, to which
   6.802 +    ///we would like to define the \ref ReachedMap.
   6.803 +    static ReachedMap *createReachedMap(const GR &G)
   6.804 +    {
   6.805 +      return new ReachedMap(G);
   6.806 +    }
   6.807 +    ///The type of the map that stores the dists of the nodes.
   6.808 + 
   6.809 +    ///The type of the map that stores the dists of the nodes.
   6.810 +    ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
   6.811 +    ///
   6.812 +    typedef NullMap<typename Digraph::Node,int> DistMap;
   6.813 +    ///Instantiates a DistMap.
   6.814 + 
   6.815 +    ///This function instantiates a \ref DistMap. 
   6.816 +    ///\param g is the digraph, to which we would like to define the \ref DistMap
   6.817 +#ifdef DOXYGEN
   6.818 +    static DistMap *createDistMap(const GR &g)
   6.819 +#else
   6.820 +    static DistMap *createDistMap(const GR &)
   6.821 +#endif
   6.822 +    {
   6.823 +      return new DistMap();
   6.824 +    }
   6.825 +  };
   6.826 +  
   6.827 +  /// Default traits used by \ref DfsWizard
   6.828 +
   6.829 +  /// To make it easier to use Dfs algorithm
   6.830 +  ///we have created a wizard class.
   6.831 +  /// This \ref DfsWizard class needs default traits,
   6.832 +  ///as well as the \ref Dfs class.
   6.833 +  /// The \ref DfsWizardBase is a class to be the default traits of the
   6.834 +  /// \ref DfsWizard class.
   6.835 +  template<class GR>
   6.836 +  class DfsWizardBase : public DfsWizardDefaultTraits<GR>
   6.837 +  {
   6.838 +
   6.839 +    typedef DfsWizardDefaultTraits<GR> Base;
   6.840 +  protected:
   6.841 +    /// Type of the nodes in the digraph.
   6.842 +    typedef typename Base::Digraph::Node Node;
   6.843 +
   6.844 +    /// Pointer to the underlying digraph.
   6.845 +    void *_g;
   6.846 +    ///Pointer to the map of reached nodes.
   6.847 +    void *_reached;
   6.848 +    ///Pointer to the map of processed nodes.
   6.849 +    void *_processed;
   6.850 +    ///Pointer to the map of predecessors arcs.
   6.851 +    void *_pred;
   6.852 +    ///Pointer to the map of distances.
   6.853 +    void *_dist;
   6.854 +    ///Pointer to the source node.
   6.855 +    Node _source;
   6.856 +    
   6.857 +    public:
   6.858 +    /// Constructor.
   6.859 +    
   6.860 +    /// This constructor does not require parameters, therefore it initiates
   6.861 +    /// all of the attributes to default values (0, INVALID).
   6.862 +    DfsWizardBase() : _g(0), _reached(0), _processed(0), _pred(0),
   6.863 +			   _dist(0), _source(INVALID) {}
   6.864 +
   6.865 +    /// Constructor.
   6.866 +    
   6.867 +    /// This constructor requires some parameters,
   6.868 +    /// listed in the parameters list.
   6.869 +    /// Others are initiated to 0.
   6.870 +    /// \param g is the initial value of  \ref _g
   6.871 +    /// \param s is the initial value of  \ref _source
   6.872 +    DfsWizardBase(const GR &g, Node s=INVALID) :
   6.873 +      _g(reinterpret_cast<void*>(const_cast<GR*>(&g))), 
   6.874 +      _reached(0), _processed(0), _pred(0), _dist(0), _source(s) {}
   6.875 +
   6.876 +  };
   6.877 +  
   6.878 +  /// A class to make the usage of the Dfs algorithm easier
   6.879 +
   6.880 +  /// This class is created to make it easier to use the Dfs algorithm.
   6.881 +  /// It uses the functions and features of the plain \ref Dfs,
   6.882 +  /// but it is much simpler to use it.
   6.883 +  ///
   6.884 +  /// Simplicity means that the way to change the types defined
   6.885 +  /// in the traits class is based on functions that returns the new class
   6.886 +  /// and not on templatable built-in classes.
   6.887 +  /// When using the plain \ref Dfs
   6.888 +  /// the new class with the modified type comes from
   6.889 +  /// the original class by using the ::
   6.890 +  /// operator. In the case of \ref DfsWizard only
   6.891 +  /// a function have to be called and it will
   6.892 +  /// return the needed class.
   6.893 +  ///
   6.894 +  /// It does not have own \ref run method. When its \ref run method is called
   6.895 +  /// it initiates a plain \ref Dfs object, and calls the \ref Dfs::run
   6.896 +  /// method of it.
   6.897 +  template<class TR>
   6.898 +  class DfsWizard : public TR
   6.899 +  {
   6.900 +    typedef TR Base;
   6.901 +
   6.902 +    ///The type of the underlying digraph.
   6.903 +    typedef typename TR::Digraph Digraph;
   6.904 +    //\e
   6.905 +    typedef typename Digraph::Node Node;
   6.906 +    //\e
   6.907 +    typedef typename Digraph::NodeIt NodeIt;
   6.908 +    //\e
   6.909 +    typedef typename Digraph::Arc Arc;
   6.910 +    //\e
   6.911 +    typedef typename Digraph::OutArcIt OutArcIt;
   6.912 +    
   6.913 +    ///\brief The type of the map that stores
   6.914 +    ///the reached nodes
   6.915 +    typedef typename TR::ReachedMap ReachedMap;
   6.916 +    ///\brief The type of the map that stores
   6.917 +    ///the processed nodes
   6.918 +    typedef typename TR::ProcessedMap ProcessedMap;
   6.919 +    ///\brief The type of the map that stores the last
   6.920 +    ///arcs of the %DFS paths.
   6.921 +    typedef typename TR::PredMap PredMap;
   6.922 +    ///The type of the map that stores the distances of the nodes.
   6.923 +    typedef typename TR::DistMap DistMap;
   6.924 +
   6.925 +  public:
   6.926 +    /// Constructor.
   6.927 +    DfsWizard() : TR() {}
   6.928 +
   6.929 +    /// Constructor that requires parameters.
   6.930 +
   6.931 +    /// Constructor that requires parameters.
   6.932 +    /// These parameters will be the default values for the traits class.
   6.933 +    DfsWizard(const Digraph &g, Node s=INVALID) :
   6.934 +      TR(g,s) {}
   6.935 +
   6.936 +    ///Copy constructor
   6.937 +    DfsWizard(const TR &b) : TR(b) {}
   6.938 +
   6.939 +    ~DfsWizard() {}
   6.940 +
   6.941 +    ///Runs Dfs algorithm from a given node.
   6.942 +    
   6.943 +    ///Runs Dfs algorithm from a given node.
   6.944 +    ///The node can be given by the \ref source function.
   6.945 +    void run()
   6.946 +    {
   6.947 +      if(Base::_source==INVALID) throw UninitializedParameter();
   6.948 +      Dfs<Digraph,TR> alg(*reinterpret_cast<const Digraph*>(Base::_g));
   6.949 +      if(Base::_reached) 
   6.950 +        alg.reachedMap(*reinterpret_cast<ReachedMap*>(Base::_reached));
   6.951 +      if(Base::_processed) 
   6.952 +        alg.processedMap(*reinterpret_cast<ProcessedMap*>(Base::_processed));
   6.953 +      if(Base::_pred) 
   6.954 +        alg.predMap(*reinterpret_cast<PredMap*>(Base::_pred));
   6.955 +      if(Base::_dist) 
   6.956 +        alg.distMap(*reinterpret_cast<DistMap*>(Base::_dist));
   6.957 +      alg.run(Base::_source);
   6.958 +    }
   6.959 +
   6.960 +    ///Runs Dfs algorithm from the given node.
   6.961 +
   6.962 +    ///Runs Dfs algorithm from the given node.
   6.963 +    ///\param s is the given source.
   6.964 +    void run(Node s)
   6.965 +    {
   6.966 +      Base::_source=s;
   6.967 +      run();
   6.968 +    }
   6.969 +
   6.970 +    template<class T>
   6.971 +    struct DefPredMapBase : public Base {
   6.972 +      typedef T PredMap;
   6.973 +      static PredMap *createPredMap(const Digraph &) { return 0; };
   6.974 +      DefPredMapBase(const TR &b) : TR(b) {}
   6.975 +    };
   6.976 +    
   6.977 +    ///\brief \ref named-templ-param "Named parameter"
   6.978 +    ///function for setting PredMap type
   6.979 +    ///
   6.980 +    /// \ref named-templ-param "Named parameter"
   6.981 +    ///function for setting PredMap type
   6.982 +    ///
   6.983 +    template<class T>
   6.984 +    DfsWizard<DefPredMapBase<T> > predMap(const T &t) 
   6.985 +    {
   6.986 +      Base::_pred=reinterpret_cast<void*>(const_cast<T*>(&t));
   6.987 +      return DfsWizard<DefPredMapBase<T> >(*this);
   6.988 +    }
   6.989 +    
   6.990 + 
   6.991 +    template<class T>
   6.992 +    struct DefReachedMapBase : public Base {
   6.993 +      typedef T ReachedMap;
   6.994 +      static ReachedMap *createReachedMap(const Digraph &) { return 0; };
   6.995 +      DefReachedMapBase(const TR &b) : TR(b) {}
   6.996 +    };
   6.997 +    
   6.998 +    ///\brief \ref named-templ-param "Named parameter"
   6.999 +    ///function for setting ReachedMap
  6.1000 +    ///
  6.1001 +    /// \ref named-templ-param "Named parameter"
  6.1002 +    ///function for setting ReachedMap
  6.1003 +    ///
  6.1004 +    template<class T>
  6.1005 +    DfsWizard<DefReachedMapBase<T> > reachedMap(const T &t) 
  6.1006 +    {
  6.1007 +      Base::_pred=reinterpret_cast<void*>(const_cast<T*>(&t));
  6.1008 +      return DfsWizard<DefReachedMapBase<T> >(*this);
  6.1009 +    }
  6.1010 +    
  6.1011 +
  6.1012 +    template<class T>
  6.1013 +    struct DefProcessedMapBase : public Base {
  6.1014 +      typedef T ProcessedMap;
  6.1015 +      static ProcessedMap *createProcessedMap(const Digraph &) { return 0; };
  6.1016 +      DefProcessedMapBase(const TR &b) : TR(b) {}
  6.1017 +    };
  6.1018 +    
  6.1019 +    ///\brief \ref named-templ-param "Named parameter"
  6.1020 +    ///function for setting ProcessedMap
  6.1021 +    ///
  6.1022 +    /// \ref named-templ-param "Named parameter"
  6.1023 +    ///function for setting ProcessedMap
  6.1024 +    ///
  6.1025 +    template<class T>
  6.1026 +    DfsWizard<DefProcessedMapBase<T> > processedMap(const T &t) 
  6.1027 +    {
  6.1028 +      Base::_pred=reinterpret_cast<void*>(const_cast<T*>(&t));
  6.1029 +      return DfsWizard<DefProcessedMapBase<T> >(*this);
  6.1030 +    }
  6.1031 +    
  6.1032 +    template<class T>
  6.1033 +    struct DefDistMapBase : public Base {
  6.1034 +      typedef T DistMap;
  6.1035 +      static DistMap *createDistMap(const Digraph &) { return 0; };
  6.1036 +      DefDistMapBase(const TR &b) : TR(b) {}
  6.1037 +    };
  6.1038 +    
  6.1039 +    ///\brief \ref named-templ-param "Named parameter"
  6.1040 +    ///function for setting DistMap type
  6.1041 +    ///
  6.1042 +    /// \ref named-templ-param "Named parameter"
  6.1043 +    ///function for setting DistMap type
  6.1044 +    ///
  6.1045 +    template<class T>
  6.1046 +    DfsWizard<DefDistMapBase<T> > distMap(const T &t) 
  6.1047 +    {
  6.1048 +      Base::_dist=reinterpret_cast<void*>(const_cast<T*>(&t));
  6.1049 +      return DfsWizard<DefDistMapBase<T> >(*this);
  6.1050 +    }
  6.1051 +    
  6.1052 +    /// Sets the source node, from which the Dfs algorithm runs.
  6.1053 +
  6.1054 +    /// Sets the source node, from which the Dfs algorithm runs.
  6.1055 +    /// \param s is the source node.
  6.1056 +    DfsWizard<TR> &source(Node s) 
  6.1057 +    {
  6.1058 +      Base::_source=s;
  6.1059 +      return *this;
  6.1060 +    }
  6.1061 +    
  6.1062 +  };
  6.1063 +  
  6.1064 +  ///Function type interface for Dfs algorithm.
  6.1065 +
  6.1066 +  ///\ingroup search
  6.1067 +  ///Function type interface for Dfs algorithm.
  6.1068 +  ///
  6.1069 +  ///This function also has several
  6.1070 +  ///\ref named-templ-func-param "named parameters",
  6.1071 +  ///they are declared as the members of class \ref DfsWizard.
  6.1072 +  ///The following
  6.1073 +  ///example shows how to use these parameters.
  6.1074 +  ///\code
  6.1075 +  ///  dfs(g,source).predMap(preds).run();
  6.1076 +  ///\endcode
  6.1077 +  ///\warning Don't forget to put the \ref DfsWizard::run() "run()"
  6.1078 +  ///to the end of the parameter list.
  6.1079 +  ///\sa DfsWizard
  6.1080 +  ///\sa Dfs
  6.1081 +  template<class GR>
  6.1082 +  DfsWizard<DfsWizardBase<GR> >
  6.1083 +  dfs(const GR &g,typename GR::Node s=INVALID)
  6.1084 +  {
  6.1085 +    return DfsWizard<DfsWizardBase<GR> >(g,s);
  6.1086 +  }
  6.1087 +
  6.1088 +#ifdef DOXYGEN
  6.1089 +  /// \brief Visitor class for dfs.
  6.1090 +  ///  
  6.1091 +  /// It gives a simple interface for a functional interface for dfs 
  6.1092 +  /// traversal. The traversal on a linear data structure. 
  6.1093 +  template <typename _Digraph>
  6.1094 +  struct DfsVisitor {
  6.1095 +    typedef _Digraph Digraph;
  6.1096 +    typedef typename Digraph::Arc Arc;
  6.1097 +    typedef typename Digraph::Node Node;
  6.1098 +    /// \brief Called when the arc reach a node.
  6.1099 +    /// 
  6.1100 +    /// It is called when the dfs find an arc which target is not
  6.1101 +    /// reached yet.
  6.1102 +    void discover(const Arc& arc) {}
  6.1103 +    /// \brief Called when the node reached first time.
  6.1104 +    /// 
  6.1105 +    /// It is Called when the node reached first time.
  6.1106 +    void reach(const Node& node) {}
  6.1107 +    /// \brief Called when we step back on an arc.
  6.1108 +    /// 
  6.1109 +    /// It is called when the dfs should step back on the arc.
  6.1110 +    void backtrack(const Arc& arc) {}
  6.1111 +    /// \brief Called when we step back from the node.
  6.1112 +    /// 
  6.1113 +    /// It is called when we step back from the node.
  6.1114 +    void leave(const Node& node) {}
  6.1115 +    /// \brief Called when the arc examined but target of the arc 
  6.1116 +    /// already discovered.
  6.1117 +    /// 
  6.1118 +    /// It called when the arc examined but the target of the arc 
  6.1119 +    /// already discovered.
  6.1120 +    void examine(const Arc& arc) {}
  6.1121 +    /// \brief Called for the source node of the dfs.
  6.1122 +    /// 
  6.1123 +    /// It is called for the source node of the dfs.
  6.1124 +    void start(const Node& node) {}
  6.1125 +    /// \brief Called when we leave the source node of the dfs.
  6.1126 +    /// 
  6.1127 +    /// It is called when we leave the source node of the dfs.
  6.1128 +    void stop(const Node& node) {}
  6.1129 +
  6.1130 +  };
  6.1131 +#else
  6.1132 +  template <typename _Digraph>
  6.1133 +  struct DfsVisitor {
  6.1134 +    typedef _Digraph Digraph;
  6.1135 +    typedef typename Digraph::Arc Arc;
  6.1136 +    typedef typename Digraph::Node Node;
  6.1137 +    void discover(const Arc&) {}
  6.1138 +    void reach(const Node&) {}
  6.1139 +    void backtrack(const Arc&) {}
  6.1140 +    void leave(const Node&) {}
  6.1141 +    void examine(const Arc&) {}
  6.1142 +    void start(const Node&) {}
  6.1143 +    void stop(const Node&) {}
  6.1144 +
  6.1145 +    template <typename _Visitor>
  6.1146 +    struct Constraints {
  6.1147 +      void constraints() {
  6.1148 +	Arc arc;
  6.1149 +	Node node;
  6.1150 +	visitor.discover(arc);
  6.1151 +	visitor.reach(node);
  6.1152 +	visitor.backtrack(arc);
  6.1153 +	visitor.leave(node);
  6.1154 +	visitor.examine(arc);
  6.1155 +	visitor.start(node);
  6.1156 +	visitor.stop(arc);
  6.1157 +      }
  6.1158 +      _Visitor& visitor;
  6.1159 +    };
  6.1160 +  };
  6.1161 +#endif
  6.1162 +
  6.1163 +  /// \brief Default traits class of DfsVisit class.
  6.1164 +  ///
  6.1165 +  /// Default traits class of DfsVisit class.
  6.1166 +  /// \param _Digraph Digraph type.
  6.1167 +  template<class _Digraph>
  6.1168 +  struct DfsVisitDefaultTraits {
  6.1169 +
  6.1170 +    /// \brief The digraph type the algorithm runs on. 
  6.1171 +    typedef _Digraph Digraph;
  6.1172 +
  6.1173 +    /// \brief The type of the map that indicates which nodes are reached.
  6.1174 +    /// 
  6.1175 +    /// The type of the map that indicates which nodes are reached.
  6.1176 +    /// It must meet the \ref concepts::WriteMap "WriteMap" concept.
  6.1177 +    /// \todo named parameter to set this type, function to read and write.
  6.1178 +    typedef typename Digraph::template NodeMap<bool> ReachedMap;
  6.1179 +
  6.1180 +    /// \brief Instantiates a ReachedMap.
  6.1181 +    ///
  6.1182 +    /// This function instantiates a \ref ReachedMap. 
  6.1183 +    /// \param digraph is the digraph, to which
  6.1184 +    /// we would like to define the \ref ReachedMap.
  6.1185 +    static ReachedMap *createReachedMap(const Digraph &digraph) {
  6.1186 +      return new ReachedMap(digraph);
  6.1187 +    }
  6.1188 +
  6.1189 +  };
  6.1190 +  
  6.1191 +  /// %DFS Visit algorithm class.
  6.1192 +  
  6.1193 +  /// \ingroup search
  6.1194 +  /// This class provides an efficient implementation of the %DFS algorithm
  6.1195 +  /// with visitor interface.
  6.1196 +  ///
  6.1197 +  /// The %DfsVisit class provides an alternative interface to the Dfs
  6.1198 +  /// class. It works with callback mechanism, the DfsVisit object calls
  6.1199 +  /// on every dfs event the \c Visitor class member functions. 
  6.1200 +  ///
  6.1201 +  /// \param _Digraph The digraph type the algorithm runs on. The default value is
  6.1202 +  /// \ref ListDigraph. The value of _Digraph is not used directly by Dfs, it
  6.1203 +  /// is only passed to \ref DfsDefaultTraits.
  6.1204 +  /// \param _Visitor The Visitor object for the algorithm. The 
  6.1205 +  /// \ref DfsVisitor "DfsVisitor<_Digraph>" is an empty Visitor which
  6.1206 +  /// does not observe the Dfs events. If you want to observe the dfs
  6.1207 +  /// events you should implement your own Visitor class.
  6.1208 +  /// \param _Traits Traits class to set various data types used by the 
  6.1209 +  /// algorithm. The default traits class is
  6.1210 +  /// \ref DfsVisitDefaultTraits "DfsVisitDefaultTraits<_Digraph>".
  6.1211 +  /// See \ref DfsVisitDefaultTraits for the documentation of
  6.1212 +  /// a Dfs visit traits class.
  6.1213 +  ///
  6.1214 +  /// \author Jacint Szabo, Alpar Juttner and Balazs Dezso
  6.1215 +#ifdef DOXYGEN
  6.1216 +  template <typename _Digraph, typename _Visitor, typename _Traits>
  6.1217 +#else
  6.1218 +  template <typename _Digraph = ListDigraph,
  6.1219 +	    typename _Visitor = DfsVisitor<_Digraph>,
  6.1220 +	    typename _Traits = DfsDefaultTraits<_Digraph> >
  6.1221 +#endif
  6.1222 +  class DfsVisit {
  6.1223 +  public:
  6.1224 +    
  6.1225 +    /// \brief \ref Exception for uninitialized parameters.
  6.1226 +    ///
  6.1227 +    /// This error represents problems in the initialization
  6.1228 +    /// of the parameters of the algorithms.
  6.1229 +    class UninitializedParameter : public lemon::UninitializedParameter {
  6.1230 +    public:
  6.1231 +      virtual const char* what() const throw() 
  6.1232 +      {
  6.1233 +	return "lemon::DfsVisit::UninitializedParameter";
  6.1234 +      }
  6.1235 +    };
  6.1236 +
  6.1237 +    typedef _Traits Traits;
  6.1238 +
  6.1239 +    typedef typename Traits::Digraph Digraph;
  6.1240 +
  6.1241 +    typedef _Visitor Visitor;
  6.1242 +
  6.1243 +    ///The type of the map indicating which nodes are reached.
  6.1244 +    typedef typename Traits::ReachedMap ReachedMap;
  6.1245 +
  6.1246 +  private:
  6.1247 +
  6.1248 +    typedef typename Digraph::Node Node;
  6.1249 +    typedef typename Digraph::NodeIt NodeIt;
  6.1250 +    typedef typename Digraph::Arc Arc;
  6.1251 +    typedef typename Digraph::OutArcIt OutArcIt;
  6.1252 +
  6.1253 +    /// Pointer to the underlying digraph.
  6.1254 +    const Digraph *_digraph;
  6.1255 +    /// Pointer to the visitor object.
  6.1256 +    Visitor *_visitor;
  6.1257 +    ///Pointer to the map of reached status of the nodes.
  6.1258 +    ReachedMap *_reached;
  6.1259 +    ///Indicates if \ref _reached is locally allocated (\c true) or not.
  6.1260 +    bool local_reached;
  6.1261 +
  6.1262 +    std::vector<typename Digraph::Arc> _stack;
  6.1263 +    int _stack_head;
  6.1264 +
  6.1265 +    /// \brief Creates the maps if necessary.
  6.1266 +    ///
  6.1267 +    /// Creates the maps if necessary.
  6.1268 +    void create_maps() {
  6.1269 +      if(!_reached) {
  6.1270 +	local_reached = true;
  6.1271 +	_reached = Traits::createReachedMap(*_digraph);
  6.1272 +      }
  6.1273 +    }
  6.1274 +
  6.1275 +  protected:
  6.1276 +
  6.1277 +    DfsVisit() {}
  6.1278 +    
  6.1279 +  public:
  6.1280 +
  6.1281 +    typedef DfsVisit Create;
  6.1282 +
  6.1283 +    /// \name Named template parameters
  6.1284 +
  6.1285 +    ///@{
  6.1286 +    template <class T>
  6.1287 +    struct DefReachedMapTraits : public Traits {
  6.1288 +      typedef T ReachedMap;
  6.1289 +      static ReachedMap *createReachedMap(const Digraph &digraph) {
  6.1290 +	throw UninitializedParameter();
  6.1291 +      }
  6.1292 +    };
  6.1293 +    /// \brief \ref named-templ-param "Named parameter" for setting 
  6.1294 +    /// ReachedMap type
  6.1295 +    ///
  6.1296 +    /// \ref named-templ-param "Named parameter" for setting ReachedMap type
  6.1297 +    template <class T>
  6.1298 +    struct DefReachedMap : public DfsVisit< Digraph, Visitor,
  6.1299 +					    DefReachedMapTraits<T> > {
  6.1300 +      typedef DfsVisit< Digraph, Visitor, DefReachedMapTraits<T> > Create;
  6.1301 +    };
  6.1302 +    ///@}
  6.1303 +
  6.1304 +  public:      
  6.1305 +    
  6.1306 +    /// \brief Constructor.
  6.1307 +    ///
  6.1308 +    /// Constructor.
  6.1309 +    ///
  6.1310 +    /// \param digraph the digraph the algorithm will run on.
  6.1311 +    /// \param visitor The visitor of the algorithm.
  6.1312 +    ///
  6.1313 +    DfsVisit(const Digraph& digraph, Visitor& visitor) 
  6.1314 +      : _digraph(&digraph), _visitor(&visitor),
  6.1315 +	_reached(0), local_reached(false) {}
  6.1316 +    
  6.1317 +    /// \brief Destructor.
  6.1318 +    ///
  6.1319 +    /// Destructor.
  6.1320 +    ~DfsVisit() {
  6.1321 +      if(local_reached) delete _reached;
  6.1322 +    }
  6.1323 +
  6.1324 +    /// \brief Sets the map indicating if a node is reached.
  6.1325 +    ///
  6.1326 +    /// Sets the map indicating if a node is reached.
  6.1327 +    /// If you don't use this function before calling \ref run(),
  6.1328 +    /// it will allocate one. The destuctor deallocates this
  6.1329 +    /// automatically allocated map, of course.
  6.1330 +    /// \return <tt> (*this) </tt>
  6.1331 +    DfsVisit &reachedMap(ReachedMap &m) {
  6.1332 +      if(local_reached) {
  6.1333 +	delete _reached;
  6.1334 +	local_reached=false;
  6.1335 +      }
  6.1336 +      _reached = &m;
  6.1337 +      return *this;
  6.1338 +    }
  6.1339 +
  6.1340 +  public:
  6.1341 +    /// \name Execution control
  6.1342 +    /// The simplest way to execute the algorithm is to use
  6.1343 +    /// one of the member functions called \c run(...).
  6.1344 +    /// \n
  6.1345 +    /// If you need more control on the execution,
  6.1346 +    /// first you must call \ref init(), then you can adda source node
  6.1347 +    /// with \ref addSource().
  6.1348 +    /// Finally \ref start() will perform the actual path
  6.1349 +    /// computation.
  6.1350 +
  6.1351 +    /// @{
  6.1352 +    /// \brief Initializes the internal data structures.
  6.1353 +    ///
  6.1354 +    /// Initializes the internal data structures.
  6.1355 +    ///
  6.1356 +    void init() {
  6.1357 +      create_maps();
  6.1358 +      _stack.resize(countNodes(*_digraph));
  6.1359 +      _stack_head = -1;
  6.1360 +      for (NodeIt u(*_digraph) ; u != INVALID ; ++u) {
  6.1361 +	_reached->set(u, false);
  6.1362 +      }
  6.1363 +    }
  6.1364 +    
  6.1365 +    /// \brief Adds a new source node.
  6.1366 +    ///
  6.1367 +    /// Adds a new source node to the set of nodes to be processed.
  6.1368 +    void addSource(Node s) {
  6.1369 +      if(!(*_reached)[s]) {
  6.1370 +	  _reached->set(s,true);
  6.1371 +	  _visitor->start(s);
  6.1372 +	  _visitor->reach(s);
  6.1373 +	  Arc e; 
  6.1374 +	  _digraph->firstOut(e, s);
  6.1375 +	  if (e != INVALID) {
  6.1376 +	    _stack[++_stack_head] = e;
  6.1377 +	  } else {
  6.1378 +	    _visitor->leave(s);
  6.1379 +	  }
  6.1380 +	}
  6.1381 +    }
  6.1382 +    
  6.1383 +    /// \brief Processes the next arc.
  6.1384 +    ///
  6.1385 +    /// Processes the next arc.
  6.1386 +    ///
  6.1387 +    /// \return The processed arc.
  6.1388 +    ///
  6.1389 +    /// \pre The stack must not be empty!
  6.1390 +    Arc processNextArc() { 
  6.1391 +      Arc e = _stack[_stack_head];
  6.1392 +      Node m = _digraph->target(e);
  6.1393 +      if(!(*_reached)[m]) {
  6.1394 +	_visitor->discover(e);
  6.1395 +	_visitor->reach(m);
  6.1396 +	_reached->set(m, true);
  6.1397 +	_digraph->firstOut(_stack[++_stack_head], m);
  6.1398 +      } else {
  6.1399 +	_visitor->examine(e);
  6.1400 +	m = _digraph->source(e);
  6.1401 +	_digraph->nextOut(_stack[_stack_head]);
  6.1402 +      }
  6.1403 +      while (_stack_head>=0 && _stack[_stack_head] == INVALID) {
  6.1404 +	_visitor->leave(m);
  6.1405 +	--_stack_head;
  6.1406 +	if (_stack_head >= 0) {
  6.1407 +	  _visitor->backtrack(_stack[_stack_head]);
  6.1408 +	  m = _digraph->source(_stack[_stack_head]);
  6.1409 +	  _digraph->nextOut(_stack[_stack_head]);
  6.1410 +	} else {
  6.1411 +	  _visitor->stop(m);	  
  6.1412 +	}
  6.1413 +      }
  6.1414 +      return e;
  6.1415 +    }
  6.1416 +
  6.1417 +    /// \brief Next arc to be processed.
  6.1418 +    ///
  6.1419 +    /// Next arc to be processed.
  6.1420 +    ///
  6.1421 +    /// \return The next arc to be processed or INVALID if the stack is
  6.1422 +    /// empty.
  6.1423 +    Arc nextArc() { 
  6.1424 +      return _stack_head >= 0 ? _stack[_stack_head] : INVALID;
  6.1425 +    }
  6.1426 +
  6.1427 +    /// \brief Returns \c false if there are nodes
  6.1428 +    /// to be processed in the queue
  6.1429 +    ///
  6.1430 +    /// Returns \c false if there are nodes
  6.1431 +    /// to be processed in the queue
  6.1432 +    bool emptyQueue() { return _stack_head < 0; }
  6.1433 +
  6.1434 +    /// \brief Returns the number of the nodes to be processed.
  6.1435 +    ///
  6.1436 +    /// Returns the number of the nodes to be processed in the queue.
  6.1437 +    int queueSize() { return _stack_head + 1; }
  6.1438 +    
  6.1439 +    /// \brief Executes the algorithm.
  6.1440 +    ///
  6.1441 +    /// Executes the algorithm.
  6.1442 +    ///
  6.1443 +    /// \pre init() must be called and at least one node should be added
  6.1444 +    /// with addSource() before using this function.
  6.1445 +    void start() {
  6.1446 +      while ( !emptyQueue() ) processNextArc();
  6.1447 +    }
  6.1448 +    
  6.1449 +    /// \brief Executes the algorithm until \c dest is reached.
  6.1450 +    ///
  6.1451 +    /// Executes the algorithm until \c dest is reached.
  6.1452 +    ///
  6.1453 +    /// \pre init() must be called and at least one node should be added
  6.1454 +    /// with addSource() before using this function.
  6.1455 +    void start(Node dest) {
  6.1456 +      while ( !emptyQueue() && _digraph->target(_stack[_stack_head]) != dest ) 
  6.1457 +	processNextArc();
  6.1458 +    }
  6.1459 +    
  6.1460 +    /// \brief Executes the algorithm until a condition is met.
  6.1461 +    ///
  6.1462 +    /// Executes the algorithm until a condition is met.
  6.1463 +    ///
  6.1464 +    /// \pre init() must be called and at least one node should be added
  6.1465 +    /// with addSource() before using this function.
  6.1466 +    ///
  6.1467 +    /// \param em must be a bool (or convertible) arc map. The algorithm
  6.1468 +    /// will stop when it reaches an arc \c e with <tt>em[e]</tt> true.
  6.1469 +    ///
  6.1470 +    ///\return The reached arc \c e with <tt>em[e]</tt> true or
  6.1471 +    ///\c INVALID if no such arc was found.
  6.1472 +    ///
  6.1473 +    /// \warning Contrary to \ref Bfs and \ref Dijkstra, \c em is an arc map,
  6.1474 +    /// not a node map.
  6.1475 +    template <typename EM>
  6.1476 +    Arc start(const EM &em) {
  6.1477 +      while ( !emptyQueue() && !em[_stack[_stack_head]] )
  6.1478 +        processNextArc();
  6.1479 +      return emptyQueue() ? INVALID : _stack[_stack_head];
  6.1480 +    }
  6.1481 +
  6.1482 +    /// \brief Runs %DFSVisit algorithm from node \c s.
  6.1483 +    ///
  6.1484 +    /// This method runs the %DFS algorithm from a root node \c s.
  6.1485 +    /// \note d.run(s) is just a shortcut of the following code.
  6.1486 +    ///\code
  6.1487 +    ///   d.init();
  6.1488 +    ///   d.addSource(s);
  6.1489 +    ///   d.start();
  6.1490 +    ///\endcode
  6.1491 +    void run(Node s) {
  6.1492 +      init();
  6.1493 +      addSource(s);
  6.1494 +      start();
  6.1495 +    }
  6.1496 +
  6.1497 +    /// \brief Runs %DFSVisit algorithm to visit all nodes in the digraph.
  6.1498 +    
  6.1499 +    /// This method runs the %DFS algorithm in order to
  6.1500 +    /// compute the %DFS path to each node. The algorithm computes
  6.1501 +    /// - The %DFS tree.
  6.1502 +    /// - The distance of each node from the root in the %DFS tree.
  6.1503 +    ///
  6.1504 +    ///\note d.run() is just a shortcut of the following code.
  6.1505 +    ///\code
  6.1506 +    ///  d.init();
  6.1507 +    ///  for (NodeIt it(digraph); it != INVALID; ++it) {
  6.1508 +    ///    if (!d.reached(it)) {
  6.1509 +    ///      d.addSource(it);
  6.1510 +    ///      d.start();
  6.1511 +    ///    }
  6.1512 +    ///  }
  6.1513 +    ///\endcode
  6.1514 +    void run() {
  6.1515 +      init();
  6.1516 +      for (NodeIt it(*_digraph); it != INVALID; ++it) {
  6.1517 +        if (!reached(it)) {
  6.1518 +          addSource(it);
  6.1519 +          start();
  6.1520 +        }
  6.1521 +      }
  6.1522 +    }
  6.1523 +    ///@}
  6.1524 +
  6.1525 +    /// \name Query Functions
  6.1526 +    /// The result of the %DFS algorithm can be obtained using these
  6.1527 +    /// functions.\n
  6.1528 +    /// Before the use of these functions,
  6.1529 +    /// either run() or start() must be called.
  6.1530 +    ///@{
  6.1531 +    /// \brief Checks if a node is reachable from the root.
  6.1532 +    ///
  6.1533 +    /// Returns \c true if \c v is reachable from the root(s).
  6.1534 +    /// \warning The source nodes are inditated as unreachable.
  6.1535 +    /// \pre Either \ref run() or \ref start()
  6.1536 +    /// must be called before using this function.
  6.1537 +    ///
  6.1538 +    bool reached(Node v) { return (*_reached)[v]; }
  6.1539 +    ///@}
  6.1540 +  };
  6.1541 +
  6.1542 +
  6.1543 +} //END OF NAMESPACE LEMON
  6.1544 +
  6.1545 +#endif
  6.1546 +
     7.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
     7.2 +++ b/lemon/dijkstra.h	Thu Feb 07 21:37:07 2008 +0000
     7.3 @@ -0,0 +1,1209 @@
     7.4 +/* -*- C++ -*-
     7.5 + *
     7.6 + * This file is a part of LEMON, a generic C++ optimization library
     7.7 + *
     7.8 + * Copyright (C) 2003-2008
     7.9 + * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
    7.10 + * (Egervary Research Group on Combinatorial Optimization, EGRES).
    7.11 + *
    7.12 + * Permission to use, modify and distribute this software is granted
    7.13 + * provided that this copyright notice appears in all copies. For
    7.14 + * precise terms see the accompanying LICENSE file.
    7.15 + *
    7.16 + * This software is provided "AS IS" with no warranty of any kind,
    7.17 + * express or implied, and with no claim as to its suitability for any
    7.18 + * purpose.
    7.19 + *
    7.20 + */
    7.21 +
    7.22 +#ifndef LEMON_DIJKSTRA_H
    7.23 +#define LEMON_DIJKSTRA_H
    7.24 +
    7.25 +///\ingroup shortest_path
    7.26 +///\file
    7.27 +///\brief Dijkstra algorithm.
    7.28 +///
    7.29 +
    7.30 +#include <lemon/list_digraph.h>
    7.31 +#include <lemon/bin_heap.h>
    7.32 +#include <lemon/bits/path_dump.h>
    7.33 +#include <lemon/bits/invalid.h>
    7.34 +#include <lemon/error.h>
    7.35 +#include <lemon/maps.h>
    7.36 +
    7.37 +
    7.38 +namespace lemon {
    7.39 +
    7.40 +  /// \brief Default OperationTraits for the Dijkstra algorithm class.
    7.41 +  ///  
    7.42 +  /// It defines all computational operations and constants which are
    7.43 +  /// used in the Dijkstra algorithm.
    7.44 +  template <typename Value>
    7.45 +  struct DijkstraDefaultOperationTraits {
    7.46 +    /// \brief Gives back the zero value of the type.
    7.47 +    static Value zero() {
    7.48 +      return static_cast<Value>(0);
    7.49 +    }
    7.50 +    /// \brief Gives back the sum of the given two elements.
    7.51 +    static Value plus(const Value& left, const Value& right) {
    7.52 +      return left + right;
    7.53 +    }
    7.54 +    /// \brief Gives back true only if the first value less than the second.
    7.55 +    static bool less(const Value& left, const Value& right) {
    7.56 +      return left < right;
    7.57 +    }
    7.58 +  };
    7.59 +
    7.60 +  /// \brief Widest path OperationTraits for the Dijkstra algorithm class.
    7.61 +  ///  
    7.62 +  /// It defines all computational operations and constants which are
    7.63 +  /// used in the Dijkstra algorithm for widest path computation.
    7.64 +  template <typename Value>
    7.65 +  struct DijkstraWidestPathOperationTraits {
    7.66 +    /// \brief Gives back the maximum value of the type.
    7.67 +    static Value zero() {
    7.68 +      return std::numeric_limits<Value>::max();
    7.69 +    }
    7.70 +    /// \brief Gives back the minimum of the given two elements.
    7.71 +    static Value plus(const Value& left, const Value& right) {
    7.72 +      return std::min(left, right);
    7.73 +    }
    7.74 +    /// \brief Gives back true only if the first value less than the second.
    7.75 +    static bool less(const Value& left, const Value& right) {
    7.76 +      return left < right;
    7.77 +    }
    7.78 +  };
    7.79 +  
    7.80 +  ///Default traits class of Dijkstra class.
    7.81 +
    7.82 +  ///Default traits class of Dijkstra class.
    7.83 +  ///\param GR Digraph type.
    7.84 +  ///\param LM Type of length map.
    7.85 +  template<class GR, class LM>
    7.86 +  struct DijkstraDefaultTraits
    7.87 +  {
    7.88 +    ///The digraph type the algorithm runs on. 
    7.89 +    typedef GR Digraph;
    7.90 +    ///The type of the map that stores the arc lengths.
    7.91 +
    7.92 +    ///The type of the map that stores the arc lengths.
    7.93 +    ///It must meet the \ref concepts::ReadMap "ReadMap" concept.
    7.94 +    typedef LM LengthMap;
    7.95 +    //The type of the length of the arcs.
    7.96 +    typedef typename LM::Value Value;
    7.97 +    /// Operation traits for Dijkstra algorithm.
    7.98 +
    7.99 +    /// It defines the used operation by the algorithm.
   7.100 +    /// \see DijkstraDefaultOperationTraits
   7.101 +    typedef DijkstraDefaultOperationTraits<Value> OperationTraits;
   7.102 +    /// The cross reference type used by heap.
   7.103 +
   7.104 +
   7.105 +    /// The cross reference type used by heap.
   7.106 +    /// Usually it is \c Digraph::NodeMap<int>.
   7.107 +    typedef typename Digraph::template NodeMap<int> HeapCrossRef;
   7.108 +    ///Instantiates a HeapCrossRef.
   7.109 +
   7.110 +    ///This function instantiates a \c HeapCrossRef. 
   7.111 +    /// \param G is the digraph, to which we would like to define the 
   7.112 +    /// HeapCrossRef.
   7.113 +    static HeapCrossRef *createHeapCrossRef(const GR &G) 
   7.114 +    {
   7.115 +      return new HeapCrossRef(G);
   7.116 +    }
   7.117 +    
   7.118 +    ///The heap type used by Dijkstra algorithm.
   7.119 +
   7.120 +    ///The heap type used by Dijkstra algorithm.
   7.121 +    ///
   7.122 +    ///\sa BinHeap
   7.123 +    ///\sa Dijkstra
   7.124 +    typedef BinHeap<typename LM::Value, HeapCrossRef, std::less<Value> > Heap;
   7.125 +
   7.126 +    static Heap *createHeap(HeapCrossRef& R) 
   7.127 +    {
   7.128 +      return new Heap(R);
   7.129 +    }
   7.130 +
   7.131 +    ///\brief The type of the map that stores the last
   7.132 +    ///arcs of the shortest paths.
   7.133 +    /// 
   7.134 +    ///The type of the map that stores the last
   7.135 +    ///arcs of the shortest paths.
   7.136 +    ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
   7.137 +    ///
   7.138 +    typedef typename Digraph::template NodeMap<typename GR::Arc> PredMap;
   7.139 +    ///Instantiates a PredMap.
   7.140 + 
   7.141 +    ///This function instantiates a \c PredMap. 
   7.142 +    ///\param G is the digraph, to which we would like to define the PredMap.
   7.143 +    ///\todo The digraph alone may be insufficient for the initialization
   7.144 +    static PredMap *createPredMap(const GR &G) 
   7.145 +    {
   7.146 +      return new PredMap(G);
   7.147 +    }
   7.148 +
   7.149 +    ///The type of the map that stores whether a nodes is processed.
   7.150 + 
   7.151 +    ///The type of the map that stores whether a nodes is processed.
   7.152 +    ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
   7.153 +    ///By default it is a NullMap.
   7.154 +    ///\todo If it is set to a real map,
   7.155 +    ///Dijkstra::processed() should read this.
   7.156 +    ///\todo named parameter to set this type, function to read and write.
   7.157 +    typedef NullMap<typename Digraph::Node,bool> ProcessedMap;
   7.158 +    ///Instantiates a ProcessedMap.
   7.159 + 
   7.160 +    ///This function instantiates a \c ProcessedMap. 
   7.161 +    ///\param g is the digraph, to which
   7.162 +    ///we would like to define the \c ProcessedMap
   7.163 +#ifdef DOXYGEN
   7.164 +    static ProcessedMap *createProcessedMap(const GR &g)
   7.165 +#else
   7.166 +    static ProcessedMap *createProcessedMap(const GR &)
   7.167 +#endif
   7.168 +    {
   7.169 +      return new ProcessedMap();
   7.170 +    }
   7.171 +    ///The type of the map that stores the dists of the nodes.
   7.172 + 
   7.173 +    ///The type of the map that stores the dists of the nodes.
   7.174 +    ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
   7.175 +    ///
   7.176 +    typedef typename Digraph::template NodeMap<typename LM::Value> DistMap;
   7.177 +    ///Instantiates a DistMap.
   7.178 + 
   7.179 +    ///This function instantiates a \ref DistMap. 
   7.180 +    ///\param G is the digraph, to which we would like to define the \ref DistMap
   7.181 +    static DistMap *createDistMap(const GR &G)
   7.182 +    {
   7.183 +      return new DistMap(G);
   7.184 +    }
   7.185 +  };
   7.186 +  
   7.187 +  ///%Dijkstra algorithm class.
   7.188 +  
   7.189 +  /// \ingroup shortest_path
   7.190 +  ///This class provides an efficient implementation of %Dijkstra algorithm.
   7.191 +  ///The arc lengths are passed to the algorithm using a
   7.192 +  ///\ref concepts::ReadMap "ReadMap",
   7.193 +  ///so it is easy to change it to any kind of length.
   7.194 +  ///
   7.195 +  ///The type of the length is determined by the
   7.196 +  ///\ref concepts::ReadMap::Value "Value" of the length map.
   7.197 +  ///
   7.198 +  ///It is also possible to change the underlying priority heap.
   7.199 +  ///
   7.200 +  ///\param GR The digraph type the algorithm runs on. The default value
   7.201 +  ///is \ref ListDigraph. The value of GR is not used directly by
   7.202 +  ///Dijkstra, it is only passed to \ref DijkstraDefaultTraits.
   7.203 +  ///\param LM This read-only ArcMap determines the lengths of the
   7.204 +  ///arcs. It is read once for each arc, so the map may involve in
   7.205 +  ///relatively time consuming process to compute the arc length if
   7.206 +  ///it is necessary. The default map type is \ref
   7.207 +  ///concepts::Digraph::ArcMap "Digraph::ArcMap<int>".  The value
   7.208 +  ///of LM is not used directly by Dijkstra, it is only passed to \ref
   7.209 +  ///DijkstraDefaultTraits.  \param TR Traits class to set
   7.210 +  ///various data types used by the algorithm.  The default traits
   7.211 +  ///class is \ref DijkstraDefaultTraits
   7.212 +  ///"DijkstraDefaultTraits<GR,LM>".  See \ref
   7.213 +  ///DijkstraDefaultTraits for the documentation of a Dijkstra traits
   7.214 +  ///class.
   7.215 +  ///
   7.216 +  ///\author Jacint Szabo and Alpar Juttner
   7.217 +
   7.218 +#ifdef DOXYGEN
   7.219 +  template <typename GR, typename LM, typename TR>
   7.220 +#else
   7.221 +  template <typename GR=ListDigraph,
   7.222 +	    typename LM=typename GR::template ArcMap<int>,
   7.223 +	    typename TR=DijkstraDefaultTraits<GR,LM> >
   7.224 +#endif
   7.225 +  class Dijkstra {
   7.226 +  public:
   7.227 +    /**
   7.228 +     * \brief \ref Exception for uninitialized parameters.
   7.229 +     *
   7.230 +     * This error represents problems in the initialization
   7.231 +     * of the parameters of the algorithms.
   7.232 +     */
   7.233 +    class UninitializedParameter : public lemon::UninitializedParameter {
   7.234 +    public:
   7.235 +      virtual const char* what() const throw() {
   7.236 +	return "lemon::Dijkstra::UninitializedParameter";
   7.237 +      }
   7.238 +    };
   7.239 +
   7.240 +    typedef TR Traits;
   7.241 +    ///The type of the underlying digraph.
   7.242 +    typedef typename TR::Digraph Digraph;
   7.243 +    ///\e
   7.244 +    typedef typename Digraph::Node Node;
   7.245 +    ///\e
   7.246 +    typedef typename Digraph::NodeIt NodeIt;
   7.247 +    ///\e
   7.248 +    typedef typename Digraph::Arc Arc;
   7.249 +    ///\e
   7.250 +    typedef typename Digraph::OutArcIt OutArcIt;
   7.251 +    
   7.252 +    ///The type of the length of the arcs.
   7.253 +    typedef typename TR::LengthMap::Value Value;
   7.254 +    ///The type of the map that stores the arc lengths.
   7.255 +    typedef typename TR::LengthMap LengthMap;
   7.256 +    ///\brief The type of the map that stores the last
   7.257 +    ///arcs of the shortest paths.
   7.258 +    typedef typename TR::PredMap PredMap;
   7.259 +    ///The type of the map indicating if a node is processed.
   7.260 +    typedef typename TR::ProcessedMap ProcessedMap;
   7.261 +    ///The type of the map that stores the dists of the nodes.
   7.262 +    typedef typename TR::DistMap DistMap;
   7.263 +    ///The cross reference type used for the current heap.
   7.264 +    typedef typename TR::HeapCrossRef HeapCrossRef;
   7.265 +    ///The heap type used by the dijkstra algorithm.
   7.266 +    typedef typename TR::Heap Heap;
   7.267 +    ///The operation traits.
   7.268 +    typedef typename TR::OperationTraits OperationTraits;
   7.269 +  private:
   7.270 +    /// Pointer to the underlying digraph.
   7.271 +    const Digraph *G;
   7.272 +    /// Pointer to the length map
   7.273 +    const LengthMap *length;
   7.274 +    ///Pointer to the map of predecessors arcs.
   7.275 +    PredMap *_pred;
   7.276 +    ///Indicates if \ref _pred is locally allocated (\c true) or not.
   7.277 +    bool local_pred;
   7.278 +    ///Pointer to the map of distances.
   7.279 +    DistMap *_dist;
   7.280 +    ///Indicates if \ref _dist is locally allocated (\c true) or not.
   7.281 +    bool local_dist;
   7.282 +    ///Pointer to the map of processed status of the nodes.
   7.283 +    ProcessedMap *_processed;
   7.284 +    ///Indicates if \ref _processed is locally allocated (\c true) or not.
   7.285 +    bool local_processed;
   7.286 +    ///Pointer to the heap cross references.
   7.287 +    HeapCrossRef *_heap_cross_ref;
   7.288 +    ///Indicates if \ref _heap_cross_ref is locally allocated (\c true) or not.
   7.289 +    bool local_heap_cross_ref;
   7.290 +    ///Pointer to the heap.
   7.291 +    Heap *_heap;
   7.292 +    ///Indicates if \ref _heap is locally allocated (\c true) or not.
   7.293 +    bool local_heap;
   7.294 +
   7.295 +    ///Creates the maps if necessary.
   7.296 +    
   7.297 +    ///\todo Better memory allocation (instead of new).
   7.298 +    void create_maps() 
   7.299 +    {
   7.300 +      if(!_pred) {
   7.301 +	local_pred = true;
   7.302 +	_pred = Traits::createPredMap(*G);
   7.303 +      }
   7.304 +      if(!_dist) {
   7.305 +	local_dist = true;
   7.306 +	_dist = Traits::createDistMap(*G);
   7.307 +      }
   7.308 +      if(!_processed) {
   7.309 +	local_processed = true;
   7.310 +	_processed = Traits::createProcessedMap(*G);
   7.311 +      }
   7.312 +      if (!_heap_cross_ref) {
   7.313 +	local_heap_cross_ref = true;
   7.314 +	_heap_cross_ref = Traits::createHeapCrossRef(*G);
   7.315 +      }
   7.316 +      if (!_heap) {
   7.317 +	local_heap = true;
   7.318 +	_heap = Traits::createHeap(*_heap_cross_ref);
   7.319 +      }
   7.320 +    }
   7.321 +    
   7.322 +  public :
   7.323 +
   7.324 +    typedef Dijkstra Create;
   7.325 + 
   7.326 +    ///\name Named template parameters
   7.327 +
   7.328 +    ///@{
   7.329 +
   7.330 +    template <class T>
   7.331 +    struct DefPredMapTraits : public Traits {
   7.332 +      typedef T PredMap;
   7.333 +      static PredMap *createPredMap(const Digraph &)
   7.334 +      {
   7.335 +	throw UninitializedParameter();
   7.336 +      }
   7.337 +    };
   7.338 +    ///\ref named-templ-param "Named parameter" for setting PredMap type
   7.339 +
   7.340 +    ///\ref named-templ-param "Named parameter" for setting PredMap type
   7.341 +    ///
   7.342 +    template <class T>
   7.343 +    struct DefPredMap 
   7.344 +      : public Dijkstra< Digraph,	LengthMap, DefPredMapTraits<T> > {
   7.345 +      typedef Dijkstra< Digraph,	LengthMap, DefPredMapTraits<T> > Create;
   7.346 +    };
   7.347 +    
   7.348 +    template <class T>
   7.349 +    struct DefDistMapTraits : public Traits {
   7.350 +      typedef T DistMap;
   7.351 +      static DistMap *createDistMap(const Digraph &)
   7.352 +      {
   7.353 +	throw UninitializedParameter();
   7.354 +      }
   7.355 +    };
   7.356 +    ///\ref named-templ-param "Named parameter" for setting DistMap type
   7.357 +
   7.358 +    ///\ref named-templ-param "Named parameter" for setting DistMap type
   7.359 +    ///
   7.360 +    template <class T>
   7.361 +    struct DefDistMap 
   7.362 +      : public Dijkstra< Digraph, LengthMap, DefDistMapTraits<T> > { 
   7.363 +      typedef Dijkstra< Digraph, LengthMap, DefDistMapTraits<T> > Create;
   7.364 +    };
   7.365 +    
   7.366 +    template <class T>
   7.367 +    struct DefProcessedMapTraits : public Traits {
   7.368 +      typedef T ProcessedMap;
   7.369 +      static ProcessedMap *createProcessedMap(const Digraph &G) 
   7.370 +      {
   7.371 +	throw UninitializedParameter();
   7.372 +      }
   7.373 +    };
   7.374 +    ///\ref named-templ-param "Named parameter" for setting ProcessedMap type
   7.375 +
   7.376 +    ///\ref named-templ-param "Named parameter" for setting ProcessedMap type
   7.377 +    ///
   7.378 +    template <class T>
   7.379 +    struct DefProcessedMap 
   7.380 +      : public Dijkstra< Digraph,	LengthMap, DefProcessedMapTraits<T> > { 
   7.381 +      typedef Dijkstra< Digraph,	LengthMap, DefProcessedMapTraits<T> > Create;
   7.382 +    };
   7.383 +    
   7.384 +    struct DefDigraphProcessedMapTraits : public Traits {
   7.385 +      typedef typename Digraph::template NodeMap<bool> ProcessedMap;
   7.386 +      static ProcessedMap *createProcessedMap(const Digraph &G) 
   7.387 +      {
   7.388 +	return new ProcessedMap(G);
   7.389 +      }
   7.390 +    };
   7.391 +    ///\brief \ref named-templ-param "Named parameter"
   7.392 +    ///for setting the ProcessedMap type to be Digraph::NodeMap<bool>.
   7.393 +    ///
   7.394 +    ///\ref named-templ-param "Named parameter"
   7.395 +    ///for setting the ProcessedMap type to be Digraph::NodeMap<bool>.
   7.396 +    ///If you don't set it explicitely, it will be automatically allocated.
   7.397 +    template <class T>
   7.398 +    struct DefProcessedMapToBeDefaultMap 
   7.399 +      : public Dijkstra< Digraph, LengthMap, DefDigraphProcessedMapTraits> {
   7.400 +      typedef Dijkstra< Digraph, LengthMap, DefDigraphProcessedMapTraits> Create;
   7.401 +    };
   7.402 +
   7.403 +    template <class H, class CR>
   7.404 +    struct DefHeapTraits : public Traits {
   7.405 +      typedef CR HeapCrossRef;
   7.406 +      typedef H Heap;
   7.407 +      static HeapCrossRef *createHeapCrossRef(const Digraph &) {
   7.408 +	throw UninitializedParameter();
   7.409 +      }
   7.410 +      static Heap *createHeap(HeapCrossRef &) 
   7.411 +      {
   7.412 +	throw UninitializedParameter();
   7.413 +      }
   7.414 +    };
   7.415 +    ///\brief \ref named-templ-param "Named parameter" for setting
   7.416 +    ///heap and cross reference type
   7.417 +    ///
   7.418 +    ///\ref named-templ-param "Named parameter" for setting heap and cross 
   7.419 +    ///reference type
   7.420 +    ///
   7.421 +    template <class H, class CR = typename Digraph::template NodeMap<int> >
   7.422 +    struct DefHeap
   7.423 +      : public Dijkstra< Digraph,	LengthMap, DefHeapTraits<H, CR> > { 
   7.424 +      typedef Dijkstra< Digraph,	LengthMap, DefHeapTraits<H, CR> > Create;
   7.425 +    };
   7.426 +
   7.427 +    template <class H, class CR>
   7.428 +    struct DefStandardHeapTraits : public Traits {
   7.429 +      typedef CR HeapCrossRef;
   7.430 +      typedef H Heap;
   7.431 +      static HeapCrossRef *createHeapCrossRef(const Digraph &G) {
   7.432 +	return new HeapCrossRef(G);
   7.433 +      }
   7.434 +      static Heap *createHeap(HeapCrossRef &R) 
   7.435 +      {
   7.436 +	return new Heap(R);
   7.437 +      }
   7.438 +    };
   7.439 +    ///\brief \ref named-templ-param "Named parameter" for setting
   7.440 +    ///heap and cross reference type with automatic allocation
   7.441 +    ///
   7.442 +    ///\ref named-templ-param "Named parameter" for setting heap and cross 
   7.443 +    ///reference type. It can allocate the heap and the cross reference 
   7.444 +    ///object if the cross reference's constructor waits for the digraph as 
   7.445 +    ///parameter and the heap's constructor waits for the cross reference.
   7.446 +    template <class H, class CR = typename Digraph::template NodeMap<int> >
   7.447 +    struct DefStandardHeap
   7.448 +      : public Dijkstra< Digraph,	LengthMap, DefStandardHeapTraits<H, CR> > { 
   7.449 +      typedef Dijkstra< Digraph,	LengthMap, DefStandardHeapTraits<H, CR> > 
   7.450 +      Create;
   7.451 +    };
   7.452 +
   7.453 +    template <class T>
   7.454 +    struct DefOperationTraitsTraits : public Traits {
   7.455 +      typedef T OperationTraits;
   7.456 +    };
   7.457 +    
   7.458 +    /// \brief \ref named-templ-param "Named parameter" for setting 
   7.459 +    /// OperationTraits type
   7.460 +    ///
   7.461 +    /// \ref named-templ-param "Named parameter" for setting OperationTraits
   7.462 +    /// type
   7.463 +    template <class T>
   7.464 +    struct DefOperationTraits
   7.465 +      : public Dijkstra<Digraph, LengthMap, DefOperationTraitsTraits<T> > {
   7.466 +      typedef Dijkstra<Digraph, LengthMap, DefOperationTraitsTraits<T> >
   7.467 +      Create;
   7.468 +    };
   7.469 +    
   7.470 +    ///@}
   7.471 +
   7.472 +
   7.473 +  protected:
   7.474 +
   7.475 +    Dijkstra() {}
   7.476 +
   7.477 +  public:      
   7.478 +    
   7.479 +    ///Constructor.
   7.480 +    
   7.481 +    ///\param _G the digraph the algorithm will run on.
   7.482 +    ///\param _length the length map used by the algorithm.
   7.483 +    Dijkstra(const Digraph& _G, const LengthMap& _length) :
   7.484 +      G(&_G), length(&_length),
   7.485 +      _pred(NULL), local_pred(false),
   7.486 +      _dist(NULL), local_dist(false),
   7.487 +      _processed(NULL), local_processed(false),
   7.488 +      _heap_cross_ref(NULL), local_heap_cross_ref(false),
   7.489 +      _heap(NULL), local_heap(false)
   7.490 +    { }
   7.491 +    
   7.492 +    ///Destructor.
   7.493 +    ~Dijkstra() 
   7.494 +    {
   7.495 +      if(local_pred) delete _pred;
   7.496 +      if(local_dist) delete _dist;
   7.497 +      if(local_processed) delete _processed;
   7.498 +      if(local_heap_cross_ref) delete _heap_cross_ref;
   7.499 +      if(local_heap) delete _heap;
   7.500 +    }
   7.501 +
   7.502 +    ///Sets the length map.
   7.503 +
   7.504 +    ///Sets the length map.
   7.505 +    ///\return <tt> (*this) </tt>
   7.506 +    Dijkstra &lengthMap(const LengthMap &m) 
   7.507 +    {
   7.508 +      length = &m;
   7.509 +      return *this;
   7.510 +    }
   7.511 +
   7.512 +    ///Sets the map storing the predecessor arcs.
   7.513 +
   7.514 +    ///Sets the map storing the predecessor arcs.
   7.515 +    ///If you don't use this function before calling \ref run(),
   7.516 +    ///it will allocate one. The destuctor deallocates this
   7.517 +    ///automatically allocated map, of course.
   7.518 +    ///\return <tt> (*this) </tt>
   7.519 +    Dijkstra &predMap(PredMap &m) 
   7.520 +    {
   7.521 +      if(local_pred) {
   7.522 +	delete _pred;
   7.523 +	local_pred=false;
   7.524 +      }
   7.525 +      _pred = &m;
   7.526 +      return *this;
   7.527 +    }
   7.528 +
   7.529 +    ///Sets the map storing the distances calculated by the algorithm.
   7.530 +
   7.531 +    ///Sets the map storing the distances calculated by the algorithm.
   7.532 +    ///If you don't use this function before calling \ref run(),
   7.533 +    ///it will allocate one. The destuctor deallocates this
   7.534 +    ///automatically allocated map, of course.
   7.535 +    ///\return <tt> (*this) </tt>
   7.536 +    Dijkstra &distMap(DistMap &m) 
   7.537 +    {
   7.538 +      if(local_dist) {
   7.539 +	delete _dist;
   7.540 +	local_dist=false;
   7.541 +      }
   7.542 +      _dist = &m;
   7.543 +      return *this;
   7.544 +    }
   7.545 +
   7.546 +    ///Sets the heap and the cross reference used by algorithm.
   7.547 +
   7.548 +    ///Sets the heap and the cross reference used by algorithm.
   7.549 +    ///If you don't use this function before calling \ref run(),
   7.550 +    ///it will allocate one. The destuctor deallocates this
   7.551 +    ///automatically allocated heap and cross reference, of course.
   7.552 +    ///\return <tt> (*this) </tt>
   7.553 +    Dijkstra &heap(Heap& hp, HeapCrossRef &cr)
   7.554 +    {
   7.555 +      if(local_heap_cross_ref) {
   7.556 +	delete _heap_cross_ref;
   7.557 +	local_heap_cross_ref=false;
   7.558 +      }
   7.559 +      _heap_cross_ref = &cr;
   7.560 +      if(local_heap) {
   7.561 +	delete _heap;
   7.562 +	local_heap=false;
   7.563 +      }
   7.564 +      _heap = &hp;
   7.565 +      return *this;
   7.566 +    }
   7.567 +
   7.568 +  private:
   7.569 +    void finalizeNodeData(Node v,Value dst)
   7.570 +    {
   7.571 +      _processed->set(v,true);
   7.572 +      _dist->set(v, dst);
   7.573 +    }
   7.574 +
   7.575 +  public:
   7.576 +
   7.577 +    typedef PredMapPath<Digraph, PredMap> Path;
   7.578 +
   7.579 +    ///\name Execution control
   7.580 +    ///The simplest way to execute the algorithm is to use
   7.581 +    ///one of the member functions called \c run(...).
   7.582 +    ///\n
   7.583 +    ///If you need more control on the execution,
   7.584 +    ///first you must call \ref init(), then you can add several source nodes
   7.585 +    ///with \ref addSource().
   7.586 +    ///Finally \ref start() will perform the actual path
   7.587 +    ///computation.
   7.588 +
   7.589 +    ///@{
   7.590 +
   7.591 +    ///Initializes the internal data structures.
   7.592 +
   7.593 +    ///Initializes the internal data structures.
   7.594 +    ///
   7.595 +    void init()
   7.596 +    {
   7.597 +      create_maps();
   7.598 +      _heap->clear();
   7.599 +      for ( NodeIt u(*G) ; u!=INVALID ; ++u ) {
   7.600 +	_pred->set(u,INVALID);
   7.601 +	_processed->set(u,false);
   7.602 +	_heap_cross_ref->set(u,Heap::PRE_HEAP);
   7.603 +      }
   7.604 +    }
   7.605 +    
   7.606 +    ///Adds a new source node.
   7.607 +
   7.608 +    ///Adds a new source node to the priority heap.
   7.609 +    ///
   7.610 +    ///The optional second parameter is the initial distance of the node.
   7.611 +    ///
   7.612 +    ///It checks if the node has already been added to the heap and
   7.613 +    ///it is pushed to the heap only if either it was not in the heap
   7.614 +    ///or the shortest path found till then is shorter than \c dst.
   7.615 +    void addSource(Node s,Value dst=OperationTraits::zero())
   7.616 +    {
   7.617 +      if(_heap->state(s) != Heap::IN_HEAP) {
   7.618 +	_heap->push(s,dst);
   7.619 +      } else if(OperationTraits::less((*_heap)[s], dst)) {
   7.620 +	_heap->set(s,dst);
   7.621 +	_pred->set(s,INVALID);
   7.622 +      }
   7.623 +    }
   7.624 +    
   7.625 +    ///Processes the next node in the priority heap
   7.626 +
   7.627 +    ///Processes the next node in the priority heap.
   7.628 +    ///
   7.629 +    ///\return The processed node.
   7.630 +    ///
   7.631 +    ///\warning The priority heap must not be empty!
   7.632 +    Node processNextNode()
   7.633 +    {
   7.634 +      Node v=_heap->top(); 
   7.635 +      Value oldvalue=_heap->prio();
   7.636 +      _heap->pop();
   7.637 +      finalizeNodeData(v,oldvalue);
   7.638 +      
   7.639 +      for(OutArcIt e(*G,v); e!=INVALID; ++e) {
   7.640 +	Node w=G->target(e); 
   7.641 +	switch(_heap->state(w)) {
   7.642 +	case Heap::PRE_HEAP:
   7.643 +	  _heap->push(w,OperationTraits::plus(oldvalue, (*length)[e])); 
   7.644 +	  _pred->set(w,e);
   7.645 +	  break;
   7.646 +	case Heap::IN_HEAP:
   7.647 +	  {
   7.648 +	    Value newvalue = OperationTraits::plus(oldvalue, (*length)[e]);
   7.649 +	    if ( OperationTraits::less(newvalue, (*_heap)[w]) ) {
   7.650 +	      _heap->decrease(w, newvalue); 
   7.651 +	      _pred->set(w,e);
   7.652 +	    }
   7.653 +	  }
   7.654 +	  break;
   7.655 +	case Heap::POST_HEAP:
   7.656 +	  break;
   7.657 +	}
   7.658 +      }
   7.659 +      return v;
   7.660 +    }
   7.661 +
   7.662 +    ///Next node to be processed.
   7.663 +    
   7.664 +    ///Next node to be processed.
   7.665 +    ///
   7.666 +    ///\return The next node to be processed or INVALID if the priority heap
   7.667 +    /// is empty.
   7.668 +    Node nextNode()
   7.669 +    { 
   7.670 +      return !_heap->empty()?_heap->top():INVALID;
   7.671 +    }
   7.672 + 
   7.673 +    ///\brief Returns \c false if there are nodes
   7.674 +    ///to be processed in the priority heap
   7.675 +    ///
   7.676 +    ///Returns \c false if there are nodes
   7.677 +    ///to be processed in the priority heap
   7.678 +    bool emptyQueue() { return _heap->empty(); }
   7.679 +    ///Returns the number of the nodes to be processed in the priority heap
   7.680 +
   7.681 +    ///Returns the number of the nodes to be processed in the priority heap
   7.682 +    ///
   7.683 +    int queueSize() { return _heap->size(); }
   7.684 +    
   7.685 +    ///Executes the algorithm.
   7.686 +
   7.687 +    ///Executes the algorithm.
   7.688 +    ///
   7.689 +    ///\pre init() must be called and at least one node should be added
   7.690 +    ///with addSource() before using this function.
   7.691 +    ///
   7.692 +    ///This method runs the %Dijkstra algorithm from the root node(s)
   7.693 +    ///in order to
   7.694 +    ///compute the
   7.695 +    ///shortest path to each node. The algorithm computes
   7.696 +    ///- The shortest path tree.
   7.697 +    ///- The distance of each node from the root(s).
   7.698 +    ///
   7.699 +    void start()
   7.700 +    {
   7.701 +      while ( !_heap->empty() ) processNextNode();
   7.702 +    }
   7.703 +    
   7.704 +    ///Executes the algorithm until \c dest is reached.
   7.705 +
   7.706 +    ///Executes the algorithm until \c dest is reached.
   7.707 +    ///
   7.708 +    ///\pre init() must be called and at least one node should be added
   7.709 +    ///with addSource() before using this function.
   7.710 +    ///
   7.711 +    ///This method runs the %Dijkstra algorithm from the root node(s)
   7.712 +    ///in order to
   7.713 +    ///compute the
   7.714 +    ///shortest path to \c dest. The algorithm computes
   7.715 +    ///- The shortest path to \c  dest.
   7.716 +    ///- The distance of \c dest from the root(s).
   7.717 +    ///
   7.718 +    void start(Node dest)
   7.719 +    {
   7.720 +      while ( !_heap->empty() && _heap->top()!=dest ) processNextNode();
   7.721 +      if ( !_heap->empty() ) finalizeNodeData(_heap->top(),_heap->prio());
   7.722 +    }
   7.723 +    
   7.724 +    ///Executes the algorithm until a condition is met.
   7.725 +
   7.726 +    ///Executes the algorithm until a condition is met.
   7.727 +    ///
   7.728 +    ///\pre init() must be called and at least one node should be added
   7.729 +    ///with addSource() before using this function.
   7.730 +    ///
   7.731 +    ///\param nm must be a bool (or convertible) node map. The algorithm
   7.732 +    ///will stop when it reaches a node \c v with <tt>nm[v]</tt> true.
   7.733 +    ///
   7.734 +    ///\return The reached node \c v with <tt>nm[v]</tt> true or
   7.735 +    ///\c INVALID if no such node was found.
   7.736 +    template<class NodeBoolMap>
   7.737 +    Node start(const NodeBoolMap &nm)
   7.738 +    {
   7.739 +      while ( !_heap->empty() && !nm[_heap->top()] ) processNextNode();
   7.740 +      if ( _heap->empty() ) return INVALID;
   7.741 +      finalizeNodeData(_heap->top(),_heap->prio());
   7.742 +      return _heap->top();
   7.743 +    }
   7.744 +    
   7.745 +    ///Runs %Dijkstra algorithm from node \c s.
   7.746 +    
   7.747 +    ///This method runs the %Dijkstra algorithm from a root node \c s
   7.748 +    ///in order to
   7.749 +    ///compute the
   7.750 +    ///shortest path to each node. The algorithm computes
   7.751 +    ///- The shortest path tree.
   7.752 +    ///- The distance of each node from the root.
   7.753 +    ///
   7.754 +    ///\note d.run(s) is just a shortcut of the following code.
   7.755 +    ///\code
   7.756 +    ///  d.init();
   7.757 +    ///  d.addSource(s);
   7.758 +    ///  d.start();
   7.759 +    ///\endcode
   7.760 +    void run(Node s) {
   7.761 +      init();
   7.762 +      addSource(s);
   7.763 +      start();
   7.764 +    }
   7.765 +    
   7.766 +    ///Finds the shortest path between \c s and \c t.
   7.767 +    
   7.768 +    ///Finds the shortest path between \c s and \c t.
   7.769 +    ///
   7.770 +    ///\return The length of the shortest s---t path if there exists one,
   7.771 +    ///0 otherwise.
   7.772 +    ///\note Apart from the return value, d.run(s) is
   7.773 +    ///just a shortcut of the following code.
   7.774 +    ///\code
   7.775 +    ///  d.init();
   7.776 +    ///  d.addSource(s);
   7.777 +    ///  d.start(t);
   7.778 +    ///\endcode
   7.779 +    Value run(Node s,Node t) {
   7.780 +      init();
   7.781 +      addSource(s);
   7.782 +      start(t);
   7.783 +      return (*_pred)[t]==INVALID?OperationTraits::zero():(*_dist)[t];
   7.784 +    }
   7.785 +    
   7.786 +    ///@}
   7.787 +
   7.788 +    ///\name Query Functions
   7.789 +    ///The result of the %Dijkstra algorithm can be obtained using these
   7.790 +    ///functions.\n
   7.791 +    ///Before the use of these functions,
   7.792 +    ///either run() or start() must be called.
   7.793 +    
   7.794 +    ///@{
   7.795 +
   7.796 +    ///Gives back the shortest path.
   7.797 +    
   7.798 +    ///Gives back the shortest path.
   7.799 +    ///\pre The \c t should be reachable from the source.
   7.800 +    Path path(Node t) 
   7.801 +    {
   7.802 +      return Path(*G, *_pred, t);
   7.803 +    }
   7.804 +
   7.805 +    ///The distance of a node from the root.
   7.806 +
   7.807 +    ///Returns the distance of a node from the root.
   7.808 +    ///\pre \ref run() must be called before using this function.
   7.809 +    ///\warning If node \c v in unreachable from the root the return value
   7.810 +    ///of this funcion is undefined.
   7.811 +    Value dist(Node v) const { return (*_dist)[v]; }
   7.812 +
   7.813 +    ///The current distance of a node from the root.
   7.814 +
   7.815 +    ///Returns the current distance of a node from the root.
   7.816 +    ///It may be decreased in the following processes.
   7.817 +    ///\pre \c node should be reached but not processed
   7.818 +    Value currentDist(Node v) const { return (*_heap)[v]; }
   7.819 +
   7.820 +    ///Returns the 'previous arc' of the shortest path tree.
   7.821 +
   7.822 +    ///For a node \c v it returns the 'previous arc' of the shortest path tree,
   7.823 +    ///i.e. it returns the last arc of a shortest path from the root to \c
   7.824 +    ///v. It is \ref INVALID
   7.825 +    ///if \c v is unreachable from the root or if \c v=s. The
   7.826 +    ///shortest path tree used here is equal to the shortest path tree used in
   7.827 +    ///\ref predNode().  \pre \ref run() must be called before using
   7.828 +    ///this function.
   7.829 +    Arc predArc(Node v) const { return (*_pred)[v]; }
   7.830 +
   7.831 +    ///Returns the 'previous node' of the shortest path tree.
   7.832 +
   7.833 +    ///For a node \c v it returns the 'previous node' of the shortest path tree,
   7.834 +    ///i.e. it returns the last but one node from a shortest path from the
   7.835 +    ///root to \c /v. It is INVALID if \c v is unreachable from the root or if
   7.836 +    ///\c v=s. The shortest path tree used here is equal to the shortest path
   7.837 +    ///tree used in \ref predArc().  \pre \ref run() must be called before
   7.838 +    ///using this function.
   7.839 +    Node predNode(Node v) const { return (*_pred)[v]==INVALID ? INVALID:
   7.840 +				  G->source((*_pred)[v]); }
   7.841 +    
   7.842 +    ///Returns a reference to the NodeMap of distances.
   7.843 +
   7.844 +    ///Returns a reference to the NodeMap of distances. \pre \ref run() must
   7.845 +    ///be called before using this function.
   7.846 +    const DistMap &distMap() const { return *_dist;}
   7.847 + 
   7.848 +    ///Returns a reference to the shortest path tree map.
   7.849 +
   7.850 +    ///Returns a reference to the NodeMap of the arcs of the
   7.851 +    ///shortest path tree.
   7.852 +    ///\pre \ref run() must be called before using this function.
   7.853 +    const PredMap &predMap() const { return *_pred;}
   7.854 + 
   7.855 +    ///Checks if a node is reachable from the root.
   7.856 +
   7.857 +    ///Returns \c true if \c v is reachable from the root.
   7.858 +    ///\warning The source nodes are inditated as unreached.
   7.859 +    ///\pre \ref run() must be called before using this function.
   7.860 +    ///
   7.861 +    bool reached(Node v) { return (*_heap_cross_ref)[v] != Heap::PRE_HEAP; }
   7.862 +
   7.863 +    ///Checks if a node is processed.
   7.864 +
   7.865 +    ///Returns \c true if \c v is processed, i.e. the shortest
   7.866 +    ///path to \c v has already found.
   7.867 +    ///\pre \ref run() must be called before using this function.
   7.868 +    ///
   7.869 +    bool processed(Node v) { return (*_heap_cross_ref)[v] == Heap::POST_HEAP; }
   7.870 +    
   7.871 +    ///@}
   7.872 +  };
   7.873 +
   7.874 +
   7.875 +
   7.876 +
   7.877 + 
   7.878 +  ///Default traits class of Dijkstra function.
   7.879 +
   7.880 +  ///Default traits class of Dijkstra function.
   7.881 +  ///\param GR Digraph type.
   7.882 +  ///\param LM Type of length map.
   7.883 +  template<class GR, class LM>
   7.884 +  struct DijkstraWizardDefaultTraits
   7.885 +  {
   7.886 +    ///The digraph type the algorithm runs on. 
   7.887 +    typedef GR Digraph;
   7.888 +    ///The type of the map that stores the arc lengths.
   7.889 +
   7.890 +    ///The type of the map that stores the arc lengths.
   7.891 +    ///It must meet the \ref concepts::ReadMap "ReadMap" concept.
   7.892 +    typedef LM LengthMap;
   7.893 +    //The type of the length of the arcs.
   7.894 +    typedef typename LM::Value Value;
   7.895 +    /// Operation traits for Dijkstra algorithm.
   7.896 +
   7.897 +    /// It defines the used operation by the algorithm.
   7.898 +    /// \see DijkstraDefaultOperationTraits
   7.899 +    typedef DijkstraDefaultOperationTraits<Value> OperationTraits;
   7.900 +    ///The heap type used by Dijkstra algorithm.
   7.901 +
   7.902 +    /// The cross reference type used by heap.
   7.903 +
   7.904 +    /// The cross reference type used by heap.
   7.905 +    /// Usually it is \c Digraph::NodeMap<int>.
   7.906 +    typedef typename Digraph::template NodeMap<int> HeapCrossRef;
   7.907 +    ///Instantiates a HeapCrossRef.
   7.908 +
   7.909 +    ///This function instantiates a \ref HeapCrossRef. 
   7.910 +    /// \param G is the digraph, to which we would like to define the 
   7.911 +    /// HeapCrossRef.
   7.912 +    /// \todo The digraph alone may be insufficient for the initialization
   7.913 +    static HeapCrossRef *createHeapCrossRef(const GR &G) 
   7.914 +    {
   7.915 +      return new HeapCrossRef(G);
   7.916 +    }
   7.917 +    
   7.918 +    ///The heap type used by Dijkstra algorithm.
   7.919 +
   7.920 +    ///The heap type used by Dijkstra algorithm.
   7.921 +    ///
   7.922 +    ///\sa BinHeap
   7.923 +    ///\sa Dijkstra
   7.924 +    typedef BinHeap<typename LM::Value, typename GR::template NodeMap<int>,
   7.925 +		    std::less<Value> > Heap;
   7.926 +
   7.927 +    static Heap *createHeap(HeapCrossRef& R) 
   7.928 +    {
   7.929 +      return new Heap(R);
   7.930 +    }
   7.931 +
   7.932 +    ///\brief The type of the map that stores the last
   7.933 +    ///arcs of the shortest paths.
   7.934 +    /// 
   7.935 +    ///The type of the map that stores the last
   7.936 +    ///arcs of the shortest paths.
   7.937 +    ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
   7.938 +    ///
   7.939 +    typedef NullMap <typename GR::Node,typename GR::Arc> PredMap;
   7.940 +    ///Instantiates a PredMap.
   7.941 + 
   7.942 +    ///This function instantiates a \ref PredMap. 
   7.943 +    ///\param g is the digraph, to which we would like to define the PredMap.
   7.944 +    ///\todo The digraph alone may be insufficient for the initialization
   7.945 +#ifdef DOXYGEN
   7.946 +    static PredMap *createPredMap(const GR &g) 
   7.947 +#else
   7.948 +    static PredMap *createPredMap(const GR &) 
   7.949 +#endif
   7.950 +    {
   7.951 +      return new PredMap();
   7.952 +    }
   7.953 +    ///The type of the map that stores whether a nodes is processed.
   7.954 + 
   7.955 +    ///The type of the map that stores whether a nodes is processed.
   7.956 +    ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
   7.957 +    ///By default it is a NullMap.
   7.958 +    ///\todo If it is set to a real map,
   7.959 +    ///Dijkstra::processed() should read this.
   7.960 +    ///\todo named parameter to set this type, function to read and write.
   7.961 +    typedef NullMap<typename Digraph::Node,bool> ProcessedMap;
   7.962 +    ///Instantiates a ProcessedMap.
   7.963 + 
   7.964 +    ///This function instantiates a \ref ProcessedMap. 
   7.965 +    ///\param g is the digraph, to which
   7.966 +    ///we would like to define the \ref ProcessedMap
   7.967 +#ifdef DOXYGEN
   7.968 +    static ProcessedMap *createProcessedMap(const GR &g)
   7.969 +#else
   7.970 +    static ProcessedMap *createProcessedMap(const GR &)
   7.971 +#endif
   7.972 +    {
   7.973 +      return new ProcessedMap();
   7.974 +    }
   7.975 +    ///The type of the map that stores the dists of the nodes.
   7.976 + 
   7.977 +    ///The type of the map that stores the dists of the nodes.
   7.978 +    ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
   7.979 +    ///
   7.980 +    typedef NullMap<typename Digraph::Node,typename LM::Value> DistMap;
   7.981 +    ///Instantiates a DistMap.
   7.982 + 
   7.983 +    ///This function instantiates a \ref DistMap. 
   7.984 +    ///\param g is the digraph, to which we would like to define the \ref DistMap
   7.985 +#ifdef DOXYGEN
   7.986 +    static DistMap *createDistMap(const GR &g)
   7.987 +#else
   7.988 +    static DistMap *createDistMap(const GR &)
   7.989 +#endif
   7.990 +    {
   7.991 +      return new DistMap();
   7.992 +    }
   7.993 +  };
   7.994 +  
   7.995 +  /// Default traits used by \ref DijkstraWizard
   7.996 +
   7.997 +  /// To make it easier to use Dijkstra algorithm
   7.998 +  ///we have created a wizard class.
   7.999 +  /// This \ref DijkstraWizard class needs default traits,
  7.1000 +  ///as well as the \ref Dijkstra class.
  7.1001 +  /// The \ref DijkstraWizardBase is a class to be the default traits of the
  7.1002 +  /// \ref DijkstraWizard class.
  7.1003 +  /// \todo More named parameters are required...
  7.1004 +  template<class GR,class LM>
  7.1005 +  class DijkstraWizardBase : public DijkstraWizardDefaultTraits<GR,LM>
  7.1006 +  {
  7.1007 +
  7.1008 +    typedef DijkstraWizardDefaultTraits<GR,LM> Base;
  7.1009 +  protected:
  7.1010 +    /// Type of the nodes in the digraph.
  7.1011 +    typedef typename Base::Digraph::Node Node;
  7.1012 +
  7.1013 +    /// Pointer to the underlying digraph.
  7.1014 +    void *_g;
  7.1015 +    /// Pointer to the length map
  7.1016 +    void *_length;
  7.1017 +    ///Pointer to the map of predecessors arcs.
  7.1018 +    void *_pred;
  7.1019 +    ///Pointer to the map of distances.
  7.1020 +    void *_dist;
  7.1021 +    ///Pointer to the source node.
  7.1022 +    Node _source;
  7.1023 +
  7.1024 +    public:
  7.1025 +    /// Constructor.
  7.1026 +    
  7.1027 +    /// This constructor does not require parameters, therefore it initiates
  7.1028 +    /// all of the attributes to default values (0, INVALID).
  7.1029 +    DijkstraWizardBase() : _g(0), _length(0), _pred(0),
  7.1030 +			   _dist(0), _source(INVALID) {}
  7.1031 +
  7.1032 +    /// Constructor.
  7.1033 +    
  7.1034 +    /// This constructor requires some parameters,
  7.1035 +    /// listed in the parameters list.
  7.1036 +    /// Others are initiated to 0.
  7.1037 +    /// \param g is the initial value of  \ref _g
  7.1038 +    /// \param l is the initial value of  \ref _length
  7.1039 +    /// \param s is the initial value of  \ref _source
  7.1040 +    DijkstraWizardBase(const GR &g,const LM &l, Node s=INVALID) :
  7.1041 +      _g(reinterpret_cast<void*>(const_cast<GR*>(&g))), 
  7.1042 +      _length(reinterpret_cast<void*>(const_cast<LM*>(&l))), 
  7.1043 +      _pred(0), _dist(0), _source(s) {}
  7.1044 +
  7.1045 +  };
  7.1046 +  
  7.1047 +  /// A class to make the usage of Dijkstra algorithm easier
  7.1048 +
  7.1049 +  /// This class is created to make it easier to use Dijkstra algorithm.
  7.1050 +  /// It uses the functions and features of the plain \ref Dijkstra,
  7.1051 +  /// but it is much simpler to use it.
  7.1052 +  ///
  7.1053 +  /// Simplicity means that the way to change the types defined
  7.1054 +  /// in the traits class is based on functions that returns the new class
  7.1055 +  /// and not on templatable built-in classes.
  7.1056 +  /// When using the plain \ref Dijkstra
  7.1057 +  /// the new class with the modified type comes from
  7.1058 +  /// the original class by using the ::
  7.1059 +  /// operator. In the case of \ref DijkstraWizard only
  7.1060 +  /// a function have to be called and it will
  7.1061 +  /// return the needed class.
  7.1062 +  ///
  7.1063 +  /// It does not have own \ref run method. When its \ref run method is called
  7.1064 +  /// it initiates a plain \ref Dijkstra class, and calls the \ref 
  7.1065 +  /// Dijkstra::run method of it.
  7.1066 +  template<class TR>
  7.1067 +  class DijkstraWizard : public TR
  7.1068 +  {
  7.1069 +    typedef TR Base;
  7.1070 +
  7.1071 +    ///The type of the underlying digraph.
  7.1072 +    typedef typename TR::Digraph Digraph;
  7.1073 +    //\e
  7.1074 +    typedef typename Digraph::Node Node;
  7.1075 +    //\e
  7.1076 +    typedef typename Digraph::NodeIt NodeIt;
  7.1077 +    //\e
  7.1078 +    typedef typename Digraph::Arc Arc;
  7.1079 +    //\e
  7.1080 +    typedef typename Digraph::OutArcIt OutArcIt;
  7.1081 +    
  7.1082 +    ///The type of the map that stores the arc lengths.
  7.1083 +    typedef typename TR::LengthMap LengthMap;
  7.1084 +    ///The type of the length of the arcs.
  7.1085 +    typedef typename LengthMap::Value Value;
  7.1086 +    ///\brief The type of the map that stores the last
  7.1087 +    ///arcs of the shortest paths.
  7.1088 +    typedef typename TR::PredMap PredMap;
  7.1089 +    ///The type of the map that stores the dists of the nodes.
  7.1090 +    typedef typename TR::DistMap DistMap;
  7.1091 +    ///The heap type used by the dijkstra algorithm.
  7.1092 +    typedef typename TR::Heap Heap;
  7.1093 +  public:
  7.1094 +    /// Constructor.
  7.1095 +    DijkstraWizard() : TR() {}
  7.1096 +
  7.1097 +    /// Constructor that requires parameters.
  7.1098 +
  7.1099 +    /// Constructor that requires parameters.
  7.1100 +    /// These parameters will be the default values for the traits class.
  7.1101 +    DijkstraWizard(const Digraph &g,const LengthMap &l, Node s=INVALID) :
  7.1102 +      TR(g,l,s) {}
  7.1103 +
  7.1104 +    ///Copy constructor
  7.1105 +    DijkstraWizard(const TR &b) : TR(b) {}
  7.1106 +
  7.1107 +    ~DijkstraWizard() {}
  7.1108 +
  7.1109 +    ///Runs Dijkstra algorithm from a given node.
  7.1110 +    
  7.1111 +    ///Runs Dijkstra algorithm from a given node.
  7.1112 +    ///The node can be given by the \ref source function.
  7.1113 +    void run()
  7.1114 +    {
  7.1115 +      if(Base::_source==INVALID) throw UninitializedParameter();
  7.1116 +      Dijkstra<Digraph,LengthMap,TR> 
  7.1117 +	dij(*reinterpret_cast<const Digraph*>(Base::_g),
  7.1118 +            *reinterpret_cast<const LengthMap*>(Base::_length));
  7.1119 +      if(Base::_pred) dij.predMap(*reinterpret_cast<PredMap*>(Base::_pred));
  7.1120 +      if(Base::_dist) dij.distMap(*reinterpret_cast<DistMap*>(Base::_dist));
  7.1121 +      dij.run(Base::_source);
  7.1122 +    }
  7.1123 +
  7.1124 +    ///Runs Dijkstra algorithm from the given node.
  7.1125 +
  7.1126 +    ///Runs Dijkstra algorithm from the given node.
  7.1127 +    ///\param s is the given source.
  7.1128 +    void run(Node s)
  7.1129 +    {
  7.1130 +      Base::_source=s;
  7.1131 +      run();
  7.1132 +    }
  7.1133 +
  7.1134 +    template<class T>
  7.1135 +    struct DefPredMapBase : public Base {
  7.1136 +      typedef T PredMap;
  7.1137 +      static PredMap *createPredMap(const Digraph &) { return 0; };
  7.1138 +      DefPredMapBase(const TR &b) : TR(b) {}
  7.1139 +    };
  7.1140 +    
  7.1141 +    ///\brief \ref named-templ-param "Named parameter"
  7.1142 +    ///function for setting PredMap type
  7.1143 +    ///
  7.1144 +    /// \ref named-templ-param "Named parameter"
  7.1145 +    ///function for setting PredMap type
  7.1146 +    ///
  7.1147 +    template<class T>
  7.1148 +    DijkstraWizard<DefPredMapBase<T> > predMap(const T &t) 
  7.1149 +    {
  7.1150 +      Base::_pred=reinterpret_cast<void*>(const_cast<T*>(&t));
  7.1151 +      return DijkstraWizard<DefPredMapBase<T> >(*this);
  7.1152 +    }
  7.1153 +    
  7.1154 +    template<class T>
  7.1155 +    struct DefDistMapBase : public Base {
  7.1156 +      typedef T DistMap;
  7.1157 +      static DistMap *createDistMap(const Digraph &) { return 0; };
  7.1158 +      DefDistMapBase(const TR &b) : TR(b) {}
  7.1159 +    };
  7.1160 +    
  7.1161 +    ///\brief \ref named-templ-param "Named parameter"
  7.1162 +    ///function for setting DistMap type
  7.1163 +    ///
  7.1164 +    /// \ref named-templ-param "Named parameter"
  7.1165 +    ///function for setting DistMap type
  7.1166 +    ///
  7.1167 +    template<class T>
  7.1168 +    DijkstraWizard<DefDistMapBase<T> > distMap(const T &t) 
  7.1169 +    {
  7.1170 +      Base::_dist=reinterpret_cast<void*>(const_cast<T*>(&t));
  7.1171 +      return DijkstraWizard<DefDistMapBase<T> >(*this);
  7.1172 +    }
  7.1173 +    
  7.1174 +    /// Sets the source node, from which the Dijkstra algorithm runs.
  7.1175 +
  7.1176 +    /// Sets the source node, from which the Dijkstra algorithm runs.
  7.1177 +    /// \param s is the source node.
  7.1178 +    DijkstraWizard<TR> &source(Node s) 
  7.1179 +    {
  7.1180 +      Base::_source=s;
  7.1181 +      return *this;
  7.1182 +    }
  7.1183 +    
  7.1184 +  };
  7.1185 +  
  7.1186 +  ///Function type interface for Dijkstra algorithm.
  7.1187 +
  7.1188 +  /// \ingroup shortest_path
  7.1189 +  ///Function type interface for Dijkstra algorithm.
  7.1190 +  ///
  7.1191 +  ///This function also has several
  7.1192 +  ///\ref named-templ-func-param "named parameters",
  7.1193 +  ///they are declared as the members of class \ref DijkstraWizard.
  7.1194 +  ///The following
  7.1195 +  ///example shows how to use these parameters.
  7.1196 +  ///\code
  7.1197 +  ///  dijkstra(g,length,source).predMap(preds).run();
  7.1198 +  ///\endcode
  7.1199 +  ///\warning Don't forget to put the \ref DijkstraWizard::run() "run()"
  7.1200 +  ///to the end of the parameter list.
  7.1201 +  ///\sa DijkstraWizard
  7.1202 +  ///\sa Dijkstra
  7.1203 +  template<class GR, class LM>
  7.1204 +  DijkstraWizard<DijkstraWizardBase<GR,LM> >
  7.1205 +  dijkstra(const GR &g,const LM &l,typename GR::Node s=INVALID)
  7.1206 +  {
  7.1207 +    return DijkstraWizard<DijkstraWizardBase<GR,LM> >(g,l,s);
  7.1208 +  }
  7.1209 +
  7.1210 +} //END OF NAMESPACE LEMON
  7.1211 +
  7.1212 +#endif
     8.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
     8.2 +++ b/lemon/graph_utils.h	Thu Feb 07 21:37:07 2008 +0000
     8.3 @@ -0,0 +1,3179 @@
     8.4 +/* -*- C++ -*-
     8.5 + *
     8.6 + * This file is a part of LEMON, a generic C++ optimization library
     8.7 + *
     8.8 + * Copyright (C) 2003-2008
     8.9 + * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
    8.10 + * (Egervary Research Group on Combinatorial Optimization, EGRES).
    8.11 + *
    8.12 + * Permission to use, modify and distribute this software is granted
    8.13 + * provided that this copyright notice appears in all copies. For
    8.14 + * precise terms see the accompanying LICENSE file.
    8.15 + *
    8.16 + * This software is provided "AS IS" with no warranty of any kind,
    8.17 + * express or implied, and with no claim as to its suitability for any
    8.18 + * purpose.
    8.19 + *
    8.20 + */
    8.21 +
    8.22 +#ifndef LEMON_GRAPH_UTILS_H
    8.23 +#define LEMON_GRAPH_UTILS_H
    8.24 +
    8.25 +#include <iterator>
    8.26 +#include <vector>
    8.27 +#include <map>
    8.28 +#include <cmath>
    8.29 +#include <algorithm>
    8.30 +
    8.31 +#include <lemon/bits/invalid.h>
    8.32 +#include <lemon/bits/utility.h>
    8.33 +#include <lemon/maps.h>
    8.34 +#include <lemon/bits/traits.h>
    8.35 +
    8.36 +#include <lemon/bits/alteration_notifier.h>
    8.37 +#include <lemon/bits/default_map.h>
    8.38 +
    8.39 +///\ingroup gutils
    8.40 +///\file
    8.41 +///\brief Digraph utilities.
    8.42 +
    8.43 +namespace lemon {
    8.44 +
    8.45 +  /// \addtogroup gutils
    8.46 +  /// @{
    8.47 +
    8.48 +  ///Creates convenience typedefs for the digraph types and iterators
    8.49 +
    8.50 +  ///This \c \#define creates convenience typedefs for the following types
    8.51 +  ///of \c Digraph: \c Node,  \c NodeIt, \c Arc, \c ArcIt, \c InArcIt,
    8.52 +  ///\c OutArcIt
    8.53 +  ///\note If \c G it a template parameter, it should be used in this way.
    8.54 +  ///\code
    8.55 +  ///  GRAPH_TYPEDEFS(typename G);
    8.56 +  ///\endcode
    8.57 +  ///
    8.58 +  ///\warning There are no typedefs for the digraph maps because of the lack of
    8.59 +  ///template typedefs in C++.
    8.60 +#define GRAPH_TYPEDEFS(Digraph)				\
    8.61 +  typedef Digraph::     Node      Node;			\
    8.62 +    typedef Digraph::   NodeIt    NodeIt;			\
    8.63 +    typedef Digraph::   Arc      Arc;			\
    8.64 +    typedef Digraph::   ArcIt    ArcIt;			\
    8.65 +    typedef Digraph:: InArcIt  InArcIt;			\
    8.66 +    typedef Digraph::OutArcIt OutArcIt
    8.67 +
    8.68 +  ///Creates convenience typedefs for the graph types and iterators
    8.69 +
    8.70 +  ///This \c \#define creates the same convenience typedefs as defined by
    8.71 +  ///\ref GRAPH_TYPEDEFS(Digraph) and three more, namely it creates
    8.72 +  ///\c Edge, \c EdgeIt, \c IncArcIt,
    8.73 +  ///
    8.74 +  ///\note If \c G it a template parameter, it should be used in this way.
    8.75 +  ///\code
    8.76 +  ///  UGRAPH_TYPEDEFS(typename G);
    8.77 +  ///\endcode
    8.78 +  ///
    8.79 +  ///\warning There are no typedefs for the digraph maps because of the lack of
    8.80 +  ///template typedefs in C++.
    8.81 +#define UGRAPH_TYPEDEFS(Digraph)				\
    8.82 +  GRAPH_TYPEDEFS(Digraph);				\
    8.83 +    typedef Digraph:: Edge   Edge;			\
    8.84 +    typedef Digraph:: EdgeIt EdgeIt;			\
    8.85 +    typedef Digraph:: IncArcIt   IncArcIt
    8.86 +
    8.87 +  ///\brief Creates convenience typedefs for the bipartite digraph 
    8.88 +  ///types and iterators
    8.89 +
    8.90 +  ///This \c \#define creates the same convenience typedefs as defined by
    8.91 +  ///\ref UGRAPH_TYPEDEFS(Digraph) and two more, namely it creates
    8.92 +  ///\c RedIt, \c BlueIt, 
    8.93 +  ///
    8.94 +  ///\note If \c G it a template parameter, it should be used in this way.
    8.95 +  ///\code
    8.96 +  ///  BPUGRAPH_TYPEDEFS(typename G);
    8.97 +  ///\endcode
    8.98 +  ///
    8.99 +  ///\warning There are no typedefs for the digraph maps because of the lack of
   8.100 +  ///template typedefs in C++.
   8.101 +#define BPUGRAPH_TYPEDEFS(Digraph)            \
   8.102 +  UGRAPH_TYPEDEFS(Digraph);		    \
   8.103 +    typedef Digraph::Red Red;             \
   8.104 +    typedef Digraph::Blue Blue;             \
   8.105 +    typedef Digraph::RedIt RedIt;	    \
   8.106 +    typedef Digraph::BlueIt BlueIt
   8.107 +
   8.108 +  /// \brief Function to count the items in the digraph.
   8.109 +  ///
   8.110 +  /// This function counts the items (nodes, arcs etc) in the digraph.
   8.111 +  /// The complexity of the function is O(n) because
   8.112 +  /// it iterates on all of the items.
   8.113 +
   8.114 +  template <typename Digraph, typename Item>
   8.115 +  inline int countItems(const Digraph& g) {
   8.116 +    typedef typename ItemSetTraits<Digraph, Item>::ItemIt ItemIt;
   8.117 +    int num = 0;
   8.118 +    for (ItemIt it(g); it != INVALID; ++it) {
   8.119 +      ++num;
   8.120 +    }
   8.121 +    return num;
   8.122 +  }
   8.123 +
   8.124 +  // Node counting:
   8.125 +
   8.126 +  namespace _digraph_utils_bits {
   8.127 +    
   8.128 +    template <typename Digraph, typename Enable = void>
   8.129 +    struct CountNodesSelector {
   8.130 +      static int count(const Digraph &g) {
   8.131 +        return countItems<Digraph, typename Digraph::Node>(g);
   8.132 +      }
   8.133 +    };
   8.134 +
   8.135 +    template <typename Digraph>
   8.136 +    struct CountNodesSelector<
   8.137 +      Digraph, typename 
   8.138 +      enable_if<typename Digraph::NodeNumTag, void>::type> 
   8.139 +    {
   8.140 +      static int count(const Digraph &g) {
   8.141 +        return g.nodeNum();
   8.142 +      }
   8.143 +    };    
   8.144 +  }
   8.145 +
   8.146 +  /// \brief Function to count the nodes in the digraph.
   8.147 +  ///
   8.148 +  /// This function counts the nodes in the digraph.
   8.149 +  /// The complexity of the function is O(n) but for some
   8.150 +  /// digraph structures it is specialized to run in O(1).
   8.151 +  ///
   8.152 +  /// If the digraph contains a \e nodeNum() member function and a 
   8.153 +  /// \e NodeNumTag tag then this function calls directly the member
   8.154 +  /// function to query the cardinality of the node set.
   8.155 +  template <typename Digraph>
   8.156 +  inline int countNodes(const Digraph& g) {
   8.157 +    return _digraph_utils_bits::CountNodesSelector<Digraph>::count(g);
   8.158 +  }
   8.159 +
   8.160 +  namespace _digraph_utils_bits {
   8.161 +    
   8.162 +    template <typename Digraph, typename Enable = void>
   8.163 +    struct CountRedsSelector {
   8.164 +      static int count(const Digraph &g) {
   8.165 +        return countItems<Digraph, typename Digraph::Red>(g);
   8.166 +      }
   8.167 +    };
   8.168 +
   8.169 +    template <typename Digraph>
   8.170 +    struct CountRedsSelector<
   8.171 +      Digraph, typename 
   8.172 +      enable_if<typename Digraph::NodeNumTag, void>::type> 
   8.173 +    {
   8.174 +      static int count(const Digraph &g) {
   8.175 +        return g.redNum();
   8.176 +      }
   8.177 +    };    
   8.178 +  }
   8.179 +
   8.180 +  /// \brief Function to count the reds in the digraph.
   8.181 +  ///
   8.182 +  /// This function counts the reds in the digraph.
   8.183 +  /// The complexity of the function is O(an) but for some
   8.184 +  /// digraph structures it is specialized to run in O(1).
   8.185 +  ///
   8.186 +  /// If the digraph contains an \e redNum() member function and a 
   8.187 +  /// \e NodeNumTag tag then this function calls directly the member
   8.188 +  /// function to query the cardinality of the A-node set.
   8.189 +  template <typename Digraph>
   8.190 +  inline int countReds(const Digraph& g) {
   8.191 +    return _digraph_utils_bits::CountRedsSelector<Digraph>::count(g);
   8.192 +  }
   8.193 +
   8.194 +  namespace _digraph_utils_bits {
   8.195 +    
   8.196 +    template <typename Digraph, typename Enable = void>
   8.197 +    struct CountBluesSelector {
   8.198 +      static int count(const Digraph &g) {
   8.199 +        return countItems<Digraph, typename Digraph::Blue>(g);
   8.200 +      }
   8.201 +    };
   8.202 +
   8.203 +    template <typename Digraph>
   8.204 +    struct CountBluesSelector<
   8.205 +      Digraph, typename 
   8.206 +      enable_if<typename Digraph::NodeNumTag, void>::type> 
   8.207 +    {
   8.208 +      static int count(const Digraph &g) {
   8.209 +        return g.blueNum();
   8.210 +      }
   8.211 +    };    
   8.212 +  }
   8.213 +
   8.214 +  /// \brief Function to count the blues in the digraph.
   8.215 +  ///
   8.216 +  /// This function counts the blues in the digraph.
   8.217 +  /// The complexity of the function is O(bn) but for some
   8.218 +  /// digraph structures it is specialized to run in O(1).
   8.219 +  ///
   8.220 +  /// If the digraph contains a \e blueNum() member function and a 
   8.221 +  /// \e NodeNumTag tag then this function calls directly the member
   8.222 +  /// function to query the cardinality of the B-node set.
   8.223 +  template <typename Digraph>
   8.224 +  inline int countBlues(const Digraph& g) {
   8.225 +    return _digraph_utils_bits::CountBluesSelector<Digraph>::count(g);
   8.226 +  }
   8.227 +
   8.228 +
   8.229 +  // Arc counting:
   8.230 +
   8.231 +  namespace _digraph_utils_bits {
   8.232 +    
   8.233 +    template <typename Digraph, typename Enable = void>
   8.234 +    struct CountArcsSelector {
   8.235 +      static int count(const Digraph &g) {
   8.236 +        return countItems<Digraph, typename Digraph::Arc>(g);
   8.237 +      }
   8.238 +    };
   8.239 +
   8.240 +    template <typename Digraph>
   8.241 +    struct CountArcsSelector<
   8.242 +      Digraph, 
   8.243 +      typename enable_if<typename Digraph::ArcNumTag, void>::type> 
   8.244 +    {
   8.245 +      static int count(const Digraph &g) {
   8.246 +        return g.arcNum();
   8.247 +      }
   8.248 +    };    
   8.249 +  }
   8.250 +
   8.251 +  /// \brief Function to count the arcs in the digraph.
   8.252 +  ///
   8.253 +  /// This function counts the arcs in the digraph.
   8.254 +  /// The complexity of the function is O(e) but for some
   8.255 +  /// digraph structures it is specialized to run in O(1).
   8.256 +  ///
   8.257 +  /// If the digraph contains a \e arcNum() member function and a 
   8.258 +  /// \e ArcNumTag tag then this function calls directly the member
   8.259 +  /// function to query the cardinality of the arc set.
   8.260 +  template <typename Digraph>
   8.261 +  inline int countArcs(const Digraph& g) {
   8.262 +    return _digraph_utils_bits::CountArcsSelector<Digraph>::count(g);
   8.263 +  }
   8.264 +
   8.265 +  // Undirected arc counting:
   8.266 +  namespace _digraph_utils_bits {
   8.267 +    
   8.268 +    template <typename Digraph, typename Enable = void>
   8.269 +    struct CountEdgesSelector {
   8.270 +      static int count(const Digraph &g) {
   8.271 +        return countItems<Digraph, typename Digraph::Edge>(g);
   8.272 +      }
   8.273 +    };
   8.274 +
   8.275 +    template <typename Digraph>
   8.276 +    struct CountEdgesSelector<
   8.277 +      Digraph, 
   8.278 +      typename enable_if<typename Digraph::ArcNumTag, void>::type> 
   8.279 +    {
   8.280 +      static int count(const Digraph &g) {
   8.281 +        return g.edgeNum();
   8.282 +      }
   8.283 +    };    
   8.284 +  }
   8.285 +
   8.286 +  /// \brief Function to count the edges in the digraph.
   8.287 +  ///
   8.288 +  /// This function counts the edges in the digraph.
   8.289 +  /// The complexity of the function is O(e) but for some
   8.290 +  /// digraph structures it is specialized to run in O(1).
   8.291 +  ///
   8.292 +  /// If the digraph contains a \e edgeNum() member function and a 
   8.293 +  /// \e ArcNumTag tag then this function calls directly the member
   8.294 +  /// function to query the cardinality of the edge set.
   8.295 +  template <typename Digraph>
   8.296 +  inline int countEdges(const Digraph& g) {
   8.297 +    return _digraph_utils_bits::CountEdgesSelector<Digraph>::count(g);
   8.298 +
   8.299 +  }
   8.300 +
   8.301 +
   8.302 +  template <typename Digraph, typename DegIt>
   8.303 +  inline int countNodeDegree(const Digraph& _g, const typename Digraph::Node& _n) {
   8.304 +    int num = 0;
   8.305 +    for (DegIt it(_g, _n); it != INVALID; ++it) {
   8.306 +      ++num;
   8.307 +    }
   8.308 +    return num;
   8.309 +  }
   8.310 +
   8.311 +  /// \brief Function to count the number of the out-arcs from node \c n.
   8.312 +  ///
   8.313 +  /// This function counts the number of the out-arcs from node \c n
   8.314 +  /// in the digraph.  
   8.315 +  template <typename Digraph>
   8.316 +  inline int countOutArcs(const Digraph& _g,  const typename Digraph::Node& _n) {
   8.317 +    return countNodeDegree<Digraph, typename Digraph::OutArcIt>(_g, _n);
   8.318 +  }
   8.319 +
   8.320 +  /// \brief Function to count the number of the in-arcs to node \c n.
   8.321 +  ///
   8.322 +  /// This function counts the number of the in-arcs to node \c n
   8.323 +  /// in the digraph.  
   8.324 +  template <typename Digraph>
   8.325 +  inline int countInArcs(const Digraph& _g,  const typename Digraph::Node& _n) {
   8.326 +    return countNodeDegree<Digraph, typename Digraph::InArcIt>(_g, _n);
   8.327 +  }
   8.328 +
   8.329 +  /// \brief Function to count the number of the inc-arcs to node \c n.
   8.330 +  ///
   8.331 +  /// This function counts the number of the inc-arcs to node \c n
   8.332 +  /// in the digraph.  
   8.333 +  template <typename Digraph>
   8.334 +  inline int countIncArcs(const Digraph& _g,  const typename Digraph::Node& _n) {
   8.335 +    return countNodeDegree<Digraph, typename Digraph::IncArcIt>(_g, _n);
   8.336 +  }
   8.337 +
   8.338 +  namespace _digraph_utils_bits {
   8.339 +    
   8.340 +    template <typename Digraph, typename Enable = void>
   8.341 +    struct FindArcSelector {
   8.342 +      typedef typename Digraph::Node Node;
   8.343 +      typedef typename Digraph::Arc Arc;
   8.344 +      static Arc find(const Digraph &g, Node u, Node v, Arc e) {
   8.345 +        if (e == INVALID) {
   8.346 +          g.firstOut(e, u);
   8.347 +        } else {
   8.348 +          g.nextOut(e);
   8.349 +        }
   8.350 +        while (e != INVALID && g.target(e) != v) {
   8.351 +          g.nextOut(e);
   8.352 +        }
   8.353 +        return e;
   8.354 +      }
   8.355 +    };
   8.356 +
   8.357 +    template <typename Digraph>
   8.358 +    struct FindArcSelector<
   8.359 +      Digraph, 
   8.360 +      typename enable_if<typename Digraph::FindArcTag, void>::type> 
   8.361 +    {
   8.362 +      typedef typename Digraph::Node Node;
   8.363 +      typedef typename Digraph::Arc Arc;
   8.364 +      static Arc find(const Digraph &g, Node u, Node v, Arc prev) {
   8.365 +        return g.findArc(u, v, prev);
   8.366 +      }
   8.367 +    };    
   8.368 +  }
   8.369 +
   8.370 +  /// \brief Finds an arc between two nodes of a digraph.
   8.371 +  ///
   8.372 +  /// Finds an arc from node \c u to node \c v in digraph \c g.
   8.373 +  ///
   8.374 +  /// If \c prev is \ref INVALID (this is the default value), then
   8.375 +  /// it finds the first arc from \c u to \c v. Otherwise it looks for
   8.376 +  /// the next arc from \c u to \c v after \c prev.
   8.377 +  /// \return The found arc or \ref INVALID if there is no such an arc.
   8.378 +  ///
   8.379 +  /// Thus you can iterate through each arc from \c u to \c v as it follows.
   8.380 +  ///\code
   8.381 +  /// for(Arc e=findArc(g,u,v);e!=INVALID;e=findArc(g,u,v,e)) {
   8.382 +  ///   ...
   8.383 +  /// }
   8.384 +  ///\endcode
   8.385 +  ///
   8.386 +  ///\sa ArcLookUp
   8.387 +  ///\sa AllArcLookUp
   8.388 +  ///\sa DynArcLookUp
   8.389 +  ///\sa ConArcIt
   8.390 +  template <typename Digraph>
   8.391 +  inline typename Digraph::Arc 
   8.392 +  findArc(const Digraph &g, typename Digraph::Node u, typename Digraph::Node v,
   8.393 +           typename Digraph::Arc prev = INVALID) {
   8.394 +    return _digraph_utils_bits::FindArcSelector<Digraph>::find(g, u, v, prev);
   8.395 +  }
   8.396 +
   8.397 +  /// \brief Iterator for iterating on arcs connected the same nodes.
   8.398 +  ///
   8.399 +  /// Iterator for iterating on arcs connected the same nodes. It is 
   8.400 +  /// higher level interface for the findArc() function. You can
   8.401 +  /// use it the following way:
   8.402 +  ///\code
   8.403 +  /// for (ConArcIt<Digraph> it(g, src, trg); it != INVALID; ++it) {
   8.404 +  ///   ...
   8.405 +  /// }
   8.406 +  ///\endcode
   8.407 +  /// 
   8.408 +  ///\sa findArc()
   8.409 +  ///\sa ArcLookUp
   8.410 +  ///\sa AllArcLookUp
   8.411 +  ///\sa DynArcLookUp
   8.412 +  ///
   8.413 +  /// \author Balazs Dezso 
   8.414 +  template <typename _Digraph>
   8.415 +  class ConArcIt : public _Digraph::Arc {
   8.416 +  public:
   8.417 +
   8.418 +    typedef _Digraph Digraph;
   8.419 +    typedef typename Digraph::Arc Parent;
   8.420 +
   8.421 +    typedef typename Digraph::Arc Arc;
   8.422 +    typedef typename Digraph::Node Node;
   8.423 +
   8.424 +    /// \brief Constructor.
   8.425 +    ///
   8.426 +    /// Construct a new ConArcIt iterating on the arcs which
   8.427 +    /// connects the \c u and \c v node.
   8.428 +    ConArcIt(const Digraph& g, Node u, Node v) : digraph(g) {
   8.429 +      Parent::operator=(findArc(digraph, u, v));
   8.430 +    }
   8.431 +
   8.432 +    /// \brief Constructor.
   8.433 +    ///
   8.434 +    /// Construct a new ConArcIt which continues the iterating from 
   8.435 +    /// the \c e arc.
   8.436 +    ConArcIt(const Digraph& g, Arc e) : Parent(e), digraph(g) {}
   8.437 +    
   8.438 +    /// \brief Increment operator.
   8.439 +    ///
   8.440 +    /// It increments the iterator and gives back the next arc.
   8.441 +    ConArcIt& operator++() {
   8.442 +      Parent::operator=(findArc(digraph, digraph.source(*this), 
   8.443 +				 digraph.target(*this), *this));
   8.444 +      return *this;
   8.445 +    }
   8.446 +  private:
   8.447 +    const Digraph& digraph;
   8.448 +  };
   8.449 +
   8.450 +  namespace _digraph_utils_bits {
   8.451 +    
   8.452 +    template <typename Digraph, typename Enable = void>
   8.453 +    struct FindEdgeSelector {
   8.454 +      typedef typename Digraph::Node Node;
   8.455 +      typedef typename Digraph::Edge Edge;
   8.456 +      static Edge find(const Digraph &g, Node u, Node v, Edge e) {
   8.457 +        bool b;
   8.458 +        if (u != v) {
   8.459 +          if (e == INVALID) {
   8.460 +            g.firstInc(e, b, u);
   8.461 +          } else {
   8.462 +            b = g.source(e) == u;
   8.463 +            g.nextInc(e, b);
   8.464 +          }
   8.465 +          while (e != INVALID && (b ? g.target(e) : g.source(e)) != v) {
   8.466 +            g.nextInc(e, b);
   8.467 +          }
   8.468 +        } else {
   8.469 +          if (e == INVALID) {
   8.470 +            g.firstInc(e, b, u);
   8.471 +          } else {
   8.472 +            b = true;
   8.473 +            g.nextInc(e, b);
   8.474 +          }
   8.475 +          while (e != INVALID && (!b || g.target(e) != v)) {
   8.476 +            g.nextInc(e, b);
   8.477 +          }
   8.478 +        }
   8.479 +        return e;
   8.480 +      }
   8.481 +    };
   8.482 +
   8.483 +    template <typename Digraph>
   8.484 +    struct FindEdgeSelector<
   8.485 +      Digraph, 
   8.486 +      typename enable_if<typename Digraph::FindArcTag, void>::type> 
   8.487 +    {
   8.488 +      typedef typename Digraph::Node Node;
   8.489 +      typedef typename Digraph::Edge Edge;
   8.490 +      static Edge find(const Digraph &g, Node u, Node v, Edge prev) {
   8.491 +        return g.findEdge(u, v, prev);
   8.492 +      }
   8.493 +    };    
   8.494 +  }
   8.495 +
   8.496 +  /// \brief Finds an edge between two nodes of a digraph.
   8.497 +  ///
   8.498 +  /// Finds an edge from node \c u to node \c v in digraph \c g.
   8.499 +  /// If the node \c u and node \c v is equal then each loop arc
   8.500 +  /// will be enumerated.
   8.501 +  ///
   8.502 +  /// If \c prev is \ref INVALID (this is the default value), then
   8.503 +  /// it finds the first arc from \c u to \c v. Otherwise it looks for
   8.504 +  /// the next arc from \c u to \c v after \c prev.
   8.505 +  /// \return The found arc or \ref INVALID if there is no such an arc.
   8.506 +  ///
   8.507 +  /// Thus you can iterate through each arc from \c u to \c v as it follows.
   8.508 +  ///\code
   8.509 +  /// for(Edge e = findEdge(g,u,v); e != INVALID; 
   8.510 +  ///     e = findEdge(g,u,v,e)) {
   8.511 +  ///   ...
   8.512 +  /// }
   8.513 +  ///\endcode
   8.514 +  ///
   8.515 +  ///\sa ConArcIt
   8.516 +
   8.517 +  template <typename Digraph>
   8.518 +  inline typename Digraph::Edge 
   8.519 +  findEdge(const Digraph &g, typename Digraph::Node u, typename Digraph::Node v,
   8.520 +            typename Digraph::Edge p = INVALID) {
   8.521 +    return _digraph_utils_bits::FindEdgeSelector<Digraph>::find(g, u, v, p);
   8.522 +  }
   8.523 +
   8.524 +  /// \brief Iterator for iterating on edges connected the same nodes.
   8.525 +  ///
   8.526 +  /// Iterator for iterating on edges connected the same nodes. It is 
   8.527 +  /// higher level interface for the findEdge() function. You can
   8.528 +  /// use it the following way:
   8.529 +  ///\code
   8.530 +  /// for (ConEdgeIt<Digraph> it(g, src, trg); it != INVALID; ++it) {
   8.531 +  ///   ...
   8.532 +  /// }
   8.533 +  ///\endcode
   8.534 +  ///
   8.535 +  ///\sa findEdge()
   8.536 +  ///
   8.537 +  /// \author Balazs Dezso 
   8.538 +  template <typename _Digraph>
   8.539 +  class ConEdgeIt : public _Digraph::Edge {
   8.540 +  public:
   8.541 +
   8.542 +    typedef _Digraph Digraph;
   8.543 +    typedef typename Digraph::Edge Parent;
   8.544 +
   8.545 +    typedef typename Digraph::Edge Edge;
   8.546 +    typedef typename Digraph::Node Node;
   8.547 +
   8.548 +    /// \brief Constructor.
   8.549 +    ///
   8.550 +    /// Construct a new ConEdgeIt iterating on the arcs which
   8.551 +    /// connects the \c u and \c v node.
   8.552 +    ConEdgeIt(const Digraph& g, Node u, Node v) : digraph(g) {
   8.553 +      Parent::operator=(findEdge(digraph, u, v));
   8.554 +    }
   8.555 +
   8.556 +    /// \brief Constructor.
   8.557 +    ///
   8.558 +    /// Construct a new ConEdgeIt which continues the iterating from 
   8.559 +    /// the \c e arc.
   8.560 +    ConEdgeIt(const Digraph& g, Edge e) : Parent(e), digraph(g) {}
   8.561 +    
   8.562 +    /// \brief Increment operator.
   8.563 +    ///
   8.564 +    /// It increments the iterator and gives back the next arc.
   8.565 +    ConEdgeIt& operator++() {
   8.566 +      Parent::operator=(findEdge(digraph, digraph.source(*this), 
   8.567 +				      digraph.target(*this), *this));
   8.568 +      return *this;
   8.569 +    }
   8.570 +  private:
   8.571 +    const Digraph& digraph;
   8.572 +  };
   8.573 +
   8.574 +  /// \brief Copy a map.
   8.575 +  ///
   8.576 +  /// This function copies the \c from map to the \c to map. It uses the
   8.577 +  /// given iterator to iterate on the data structure and it uses the \c ref
   8.578 +  /// mapping to convert the from's keys to the to's keys.
   8.579 +  template <typename To, typename From, 
   8.580 +	    typename ItemIt, typename Ref>	    
   8.581 +  void copyMap(To& to, const From& from, 
   8.582 +	       ItemIt it, const Ref& ref) {
   8.583 +    for (; it != INVALID; ++it) {
   8.584 +      to[ref[it]] = from[it];
   8.585 +    }
   8.586 +  }
   8.587 +
   8.588 +  /// \brief Copy the from map to the to map.
   8.589 +  ///
   8.590 +  /// Copy the \c from map to the \c to map. It uses the given iterator
   8.591 +  /// to iterate on the data structure.
   8.592 +  template <typename To, typename From, typename ItemIt>	    
   8.593 +  void copyMap(To& to, const From& from, ItemIt it) {
   8.594 +    for (; it != INVALID; ++it) {
   8.595 +      to[it] = from[it];
   8.596 +    }
   8.597 +  }
   8.598 +
   8.599 +  namespace _digraph_utils_bits {
   8.600 +
   8.601 +    template <typename Digraph, typename Item, typename RefMap>
   8.602 +    class MapCopyBase {
   8.603 +    public:
   8.604 +      virtual void copy(const Digraph& from, const RefMap& refMap) = 0;
   8.605 +      
   8.606 +      virtual ~MapCopyBase() {}
   8.607 +    };
   8.608 +
   8.609 +    template <typename Digraph, typename Item, typename RefMap, 
   8.610 +              typename ToMap, typename FromMap>
   8.611 +    class MapCopy : public MapCopyBase<Digraph, Item, RefMap> {
   8.612 +    public:
   8.613 +
   8.614 +      MapCopy(ToMap& tmap, const FromMap& map) 
   8.615 +        : _tmap(tmap), _map(map) {}
   8.616 +      
   8.617 +      virtual void copy(const Digraph& digraph, const RefMap& refMap) {
   8.618 +        typedef typename ItemSetTraits<Digraph, Item>::ItemIt ItemIt;
   8.619 +        for (ItemIt it(digraph); it != INVALID; ++it) {
   8.620 +          _tmap.set(refMap[it], _map[it]);
   8.621 +        }
   8.622 +      }
   8.623 +
   8.624 +    private:
   8.625 +      ToMap& _tmap;
   8.626 +      const FromMap& _map;
   8.627 +    };
   8.628 +
   8.629 +    template <typename Digraph, typename Item, typename RefMap, typename It>
   8.630 +    class ItemCopy : public MapCopyBase<Digraph, Item, RefMap> {
   8.631 +    public:
   8.632 +
   8.633 +      ItemCopy(It& it, const Item& item) : _it(it), _item(item) {}
   8.634 +      
   8.635 +      virtual void copy(const Digraph&, const RefMap& refMap) {
   8.636 +        _it = refMap[_item];
   8.637 +      }
   8.638 +
   8.639 +    private:
   8.640 +      It& _it;
   8.641 +      Item _item;
   8.642 +    };
   8.643 +
   8.644 +    template <typename Digraph, typename Item, typename RefMap, typename Ref>
   8.645 +    class RefCopy : public MapCopyBase<Digraph, Item, RefMap> {
   8.646 +    public:
   8.647 +
   8.648 +      RefCopy(Ref& map) : _map(map) {}
   8.649 +      
   8.650 +      virtual void copy(const Digraph& digraph, const RefMap& refMap) {
   8.651 +        typedef typename ItemSetTraits<Digraph, Item>::ItemIt ItemIt;
   8.652 +        for (ItemIt it(digraph); it != INVALID; ++it) {
   8.653 +          _map.set(it, refMap[it]);
   8.654 +        }
   8.655 +      }
   8.656 +
   8.657 +    private:
   8.658 +      Ref& _map;
   8.659 +    };
   8.660 +
   8.661 +    template <typename Digraph, typename Item, typename RefMap, 
   8.662 +              typename CrossRef>
   8.663 +    class CrossRefCopy : public MapCopyBase<Digraph, Item, RefMap> {
   8.664 +    public:
   8.665 +
   8.666 +      CrossRefCopy(CrossRef& cmap) : _cmap(cmap) {}
   8.667 +      
   8.668 +      virtual void copy(const Digraph& digraph, const RefMap& refMap) {
   8.669 +        typedef typename ItemSetTraits<Digraph, Item>::ItemIt ItemIt;
   8.670 +        for (ItemIt it(digraph); it != INVALID; ++it) {
   8.671 +          _cmap.set(refMap[it], it);
   8.672 +        }
   8.673 +      }
   8.674 +
   8.675 +    private:
   8.676 +      CrossRef& _cmap;
   8.677 +    };
   8.678 +
   8.679 +    template <typename Digraph, typename Enable = void>
   8.680 +    struct DigraphCopySelector {
   8.681 +      template <typename From, typename NodeRefMap, typename ArcRefMap>
   8.682 +      static void copy(Digraph &to, const From& from,
   8.683 +                       NodeRefMap& nodeRefMap, ArcRefMap& arcRefMap) {
   8.684 +        for (typename From::NodeIt it(from); it != INVALID; ++it) {
   8.685 +          nodeRefMap[it] = to.addNode();
   8.686 +        }
   8.687 +        for (typename From::ArcIt it(from); it != INVALID; ++it) {
   8.688 +          arcRefMap[it] = to.addArc(nodeRefMap[from.source(it)], 
   8.689 +                                          nodeRefMap[from.target(it)]);
   8.690 +        }
   8.691 +      }
   8.692 +    };
   8.693 +
   8.694 +    template <typename Digraph>
   8.695 +    struct DigraphCopySelector<
   8.696 +      Digraph, 
   8.697 +      typename enable_if<typename Digraph::BuildTag, void>::type> 
   8.698 +    {
   8.699 +      template <typename From, typename NodeRefMap, typename ArcRefMap>
   8.700 +      static void copy(Digraph &to, const From& from,
   8.701 +                       NodeRefMap& nodeRefMap, ArcRefMap& arcRefMap) {
   8.702 +        to.build(from, nodeRefMap, arcRefMap);
   8.703 +      }
   8.704 +    };
   8.705 +
   8.706 +    template <typename Graph, typename Enable = void>
   8.707 +    struct GraphCopySelector {
   8.708 +      template <typename From, typename NodeRefMap, typename EdgeRefMap>
   8.709 +      static void copy(Graph &to, const From& from,
   8.710 +                       NodeRefMap& nodeRefMap, EdgeRefMap& edgeRefMap) {
   8.711 +        for (typename From::NodeIt it(from); it != INVALID; ++it) {
   8.712 +          nodeRefMap[it] = to.addNode();
   8.713 +        }
   8.714 +        for (typename From::EdgeIt it(from); it != INVALID; ++it) {
   8.715 +          edgeRefMap[it] = to.addArc(nodeRefMap[from.source(it)], 
   8.716 +				       nodeRefMap[from.target(it)]);
   8.717 +        }
   8.718 +      }
   8.719 +    };
   8.720 +
   8.721 +    template <typename Graph>
   8.722 +    struct GraphCopySelector<
   8.723 +      Graph, 
   8.724 +      typename enable_if<typename Graph::BuildTag, void>::type> 
   8.725 +    {
   8.726 +      template <typename From, typename NodeRefMap, typename EdgeRefMap>
   8.727 +      static void copy(Graph &to, const From& from,
   8.728 +                       NodeRefMap& nodeRefMap, EdgeRefMap& edgeRefMap) {
   8.729 +        to.build(from, nodeRefMap, edgeRefMap);
   8.730 +      }
   8.731 +    };
   8.732 +
   8.733 +    template <typename BpGraph, typename Enable = void>
   8.734 +    struct BpGraphCopySelector {
   8.735 +      template <typename From, typename RedRefMap, 
   8.736 +                typename BlueRefMap, typename EdgeRefMap>
   8.737 +      static void copy(BpGraph &to, const From& from,
   8.738 +                       RedRefMap& redRefMap, BlueRefMap& blueRefMap,
   8.739 +                       EdgeRefMap& edgeRefMap) {
   8.740 +        for (typename From::RedIt it(from); it != INVALID; ++it) {
   8.741 +          redRefMap[it] = to.addRed();
   8.742 +        }
   8.743 +        for (typename From::BlueIt it(from); it != INVALID; ++it) {
   8.744 +          blueRefMap[it] = to.addBlue();
   8.745 +        }
   8.746 +        for (typename From::EdgeIt it(from); it != INVALID; ++it) {
   8.747 +          edgeRefMap[it] = to.addArc(redRefMap[from.red(it)], 
   8.748 +                                           blueRefMap[from.blue(it)]);
   8.749 +        }
   8.750 +      }
   8.751 +    };
   8.752 +
   8.753 +    template <typename BpGraph>
   8.754 +    struct BpGraphCopySelector<
   8.755 +      BpGraph, 
   8.756 +      typename enable_if<typename BpGraph::BuildTag, void>::type> 
   8.757 +    {
   8.758 +      template <typename From, typename RedRefMap, 
   8.759 +                typename BlueRefMap, typename EdgeRefMap>
   8.760 +      static void copy(BpGraph &to, const From& from,
   8.761 +                       RedRefMap& redRefMap, BlueRefMap& blueRefMap,
   8.762 +                       EdgeRefMap& edgeRefMap) {
   8.763 +        to.build(from, redRefMap, blueRefMap, edgeRefMap);
   8.764 +      }
   8.765 +    };
   8.766 +    
   8.767 +
   8.768 +  }
   8.769 +
   8.770 +  /// \brief Class to copy a digraph.
   8.771 +  ///
   8.772 +  /// Class to copy a digraph to another digraph (duplicate a digraph). The
   8.773 +  /// simplest way of using it is through the \c copyDigraph() function.
   8.774 +  template <typename To, typename From>
   8.775 +  class DigraphCopy {
   8.776 +  private:
   8.777 +
   8.778 +    typedef typename From::Node Node;
   8.779 +    typedef typename From::NodeIt NodeIt;
   8.780 +    typedef typename From::Arc Arc;
   8.781 +    typedef typename From::ArcIt ArcIt;
   8.782 +
   8.783 +    typedef typename To::Node TNode;
   8.784 +    typedef typename To::Arc TArc;
   8.785 +
   8.786 +    typedef typename From::template NodeMap<TNode> NodeRefMap;
   8.787 +    typedef typename From::template ArcMap<TArc> ArcRefMap;
   8.788 +    
   8.789 +    
   8.790 +  public: 
   8.791 +
   8.792 +
   8.793 +    /// \brief Constructor for the DigraphCopy.
   8.794 +    ///
   8.795 +    /// It copies the content of the \c _from digraph into the
   8.796 +    /// \c _to digraph.
   8.797 +    DigraphCopy(To& _to, const From& _from) 
   8.798 +      : from(_from), to(_to) {}
   8.799 +
   8.800 +    /// \brief Destructor of the DigraphCopy
   8.801 +    ///
   8.802 +    /// Destructor of the DigraphCopy
   8.803 +    ~DigraphCopy() {
   8.804 +      for (int i = 0; i < int(nodeMapCopies.size()); ++i) {
   8.805 +        delete nodeMapCopies[i];
   8.806 +      }
   8.807 +      for (int i = 0; i < int(arcMapCopies.size()); ++i) {
   8.808 +        delete arcMapCopies[i];
   8.809 +      }
   8.810 +
   8.811 +    }
   8.812 +
   8.813 +    /// \brief Copies the node references into the given map.
   8.814 +    ///
   8.815 +    /// Copies the node references into the given map.
   8.816 +    template <typename NodeRef>
   8.817 +    DigraphCopy& nodeRef(NodeRef& map) {
   8.818 +      nodeMapCopies.push_back(new _digraph_utils_bits::RefCopy<From, Node, 
   8.819 +                              NodeRefMap, NodeRef>(map));
   8.820 +      return *this;
   8.821 +    }
   8.822 +
   8.823 +    /// \brief Copies the node cross references into the given map.
   8.824 +    ///
   8.825 +    ///  Copies the node cross references (reverse references) into
   8.826 +    ///  the given map.
   8.827 +    template <typename NodeCrossRef>
   8.828 +    DigraphCopy& nodeCrossRef(NodeCrossRef& map) {
   8.829 +      nodeMapCopies.push_back(new _digraph_utils_bits::CrossRefCopy<From, Node,
   8.830 +                              NodeRefMap, NodeCrossRef>(map));
   8.831 +      return *this;
   8.832 +    }
   8.833 +
   8.834 +    /// \brief Make copy of the given map.
   8.835 +    ///
   8.836 +    /// Makes copy of the given map for the newly created digraph. 
   8.837 +    /// The new map's key type is the to digraph's node type,
   8.838 +    /// and the copied map's key type is the from digraph's node
   8.839 +    /// type.  
   8.840 +    template <typename ToMap, typename FromMap>
   8.841 +    DigraphCopy& nodeMap(ToMap& tmap, const FromMap& map) {
   8.842 +      nodeMapCopies.push_back(new _digraph_utils_bits::MapCopy<From, Node, 
   8.843 +                              NodeRefMap, ToMap, FromMap>(tmap, map));
   8.844 +      return *this;
   8.845 +    }
   8.846 +
   8.847 +    /// \brief Make a copy of the given node.
   8.848 +    ///
   8.849 +    /// Make a copy of the given node.
   8.850 +    DigraphCopy& node(TNode& tnode, const Node& snode) {
   8.851 +      nodeMapCopies.push_back(new _digraph_utils_bits::ItemCopy<From, Node, 
   8.852 +                              NodeRefMap, TNode>(tnode, snode));
   8.853 +      return *this;
   8.854 +    }
   8.855 +
   8.856 +    /// \brief Copies the arc references into the given map.
   8.857 +    ///
   8.858 +    /// Copies the arc references into the given map.
   8.859 +    template <typename ArcRef>
   8.860 +    DigraphCopy& arcRef(ArcRef& map) {
   8.861 +      arcMapCopies.push_back(new _digraph_utils_bits::RefCopy<From, Arc, 
   8.862 +                              ArcRefMap, ArcRef>(map));
   8.863 +      return *this;
   8.864 +    }
   8.865 +
   8.866 +    /// \brief Copies the arc cross references into the given map.
   8.867 +    ///
   8.868 +    ///  Copies the arc cross references (reverse references) into
   8.869 +    ///  the given map.
   8.870 +    template <typename ArcCrossRef>
   8.871 +    DigraphCopy& arcCrossRef(ArcCrossRef& map) {
   8.872 +      arcMapCopies.push_back(new _digraph_utils_bits::CrossRefCopy<From, Arc,
   8.873 +                              ArcRefMap, ArcCrossRef>(map));
   8.874 +      return *this;
   8.875 +    }
   8.876 +
   8.877 +    /// \brief Make copy of the given map.
   8.878 +    ///
   8.879 +    /// Makes copy of the given map for the newly created digraph. 
   8.880 +    /// The new map's key type is the to digraph's arc type,
   8.881 +    /// and the copied map's key type is the from digraph's arc
   8.882 +    /// type.  
   8.883 +    template <typename ToMap, typename FromMap>
   8.884 +    DigraphCopy& arcMap(ToMap& tmap, const FromMap& map) {
   8.885 +      arcMapCopies.push_back(new _digraph_utils_bits::MapCopy<From, Arc, 
   8.886 +                              ArcRefMap, ToMap, FromMap>(tmap, map));
   8.887 +      return *this;
   8.888 +    }
   8.889 +
   8.890 +    /// \brief Make a copy of the given arc.
   8.891 +    ///
   8.892 +    /// Make a copy of the given arc.
   8.893 +    DigraphCopy& arc(TArc& tarc, const Arc& sarc) {
   8.894 +      arcMapCopies.push_back(new _digraph_utils_bits::ItemCopy<From, Arc, 
   8.895 +                              ArcRefMap, TArc>(tarc, sarc));
   8.896 +      return *this;
   8.897 +    }
   8.898 +
   8.899 +    /// \brief Executes the copies.
   8.900 +    ///
   8.901 +    /// Executes the copies.
   8.902 +    void run() {
   8.903 +      NodeRefMap nodeRefMap(from);
   8.904 +      ArcRefMap arcRefMap(from);
   8.905 +      _digraph_utils_bits::DigraphCopySelector<To>::
   8.906 +        copy(to, from, nodeRefMap, arcRefMap);
   8.907 +      for (int i = 0; i < int(nodeMapCopies.size()); ++i) {
   8.908 +        nodeMapCopies[i]->copy(from, nodeRefMap);
   8.909 +      }
   8.910 +      for (int i = 0; i < int(arcMapCopies.size()); ++i) {
   8.911 +        arcMapCopies[i]->copy(from, arcRefMap);
   8.912 +      }      
   8.913 +    }
   8.914 +
   8.915 +  protected:
   8.916 +
   8.917 +
   8.918 +    const From& from;
   8.919 +    To& to;
   8.920 +
   8.921 +    std::vector<_digraph_utils_bits::MapCopyBase<From, Node, NodeRefMap>* > 
   8.922 +    nodeMapCopies;
   8.923 +
   8.924 +    std::vector<_digraph_utils_bits::MapCopyBase<From, Arc, ArcRefMap>* > 
   8.925 +    arcMapCopies;
   8.926 +
   8.927 +  };
   8.928 +
   8.929 +  /// \brief Copy a digraph to another digraph.
   8.930 +  ///
   8.931 +  /// Copy a digraph to another digraph.
   8.932 +  /// The usage of the function:
   8.933 +  /// 
   8.934 +  ///\code
   8.935 +  /// copyDigraph(trg, src).nodeRef(nr).arcCrossRef(ecr).run();
   8.936 +  ///\endcode
   8.937 +  /// 
   8.938 +  /// After the copy the \c nr map will contain the mapping from the
   8.939 +  /// nodes of the \c from digraph to the nodes of the \c to digraph and
   8.940 +  /// \c ecr will contain the mapping from the arcs of the \c to digraph
   8.941 +  /// to the arcs of the \c from digraph.
   8.942 +  ///
   8.943 +  /// \see DigraphCopy 
   8.944 +  template <typename To, typename From>
   8.945 +  DigraphCopy<To, From> copyDigraph(To& to, const From& from) {
   8.946 +    return DigraphCopy<To, From>(to, from);
   8.947 +  }
   8.948 +
   8.949 +  /// \brief Class to copy an graph.
   8.950 +  ///
   8.951 +  /// Class to copy an graph to another digraph (duplicate a digraph).
   8.952 +  /// The simplest way of using it is through the \c copyGraph() function.
   8.953 +  template <typename To, typename From>
   8.954 +  class GraphCopy {
   8.955 +  private:
   8.956 +
   8.957 +    typedef typename From::Node Node;
   8.958 +    typedef typename From::NodeIt NodeIt;
   8.959 +    typedef typename From::Arc Arc;
   8.960 +    typedef typename From::ArcIt ArcIt;
   8.961 +    typedef typename From::Edge Edge;
   8.962 +    typedef typename From::EdgeIt EdgeIt;
   8.963 +
   8.964 +    typedef typename To::Node TNode;
   8.965 +    typedef typename To::Arc TArc;
   8.966 +    typedef typename To::Edge TEdge;
   8.967 +
   8.968 +    typedef typename From::template NodeMap<TNode> NodeRefMap;
   8.969 +    typedef typename From::template EdgeMap<TEdge> EdgeRefMap;
   8.970 +
   8.971 +    struct ArcRefMap {
   8.972 +      ArcRefMap(const To& _to, const From& _from,
   8.973 +                 const EdgeRefMap& _edge_ref, const NodeRefMap& _node_ref) 
   8.974 +        : to(_to), from(_from), 
   8.975 +          edge_ref(_edge_ref), node_ref(_node_ref) {}
   8.976 +
   8.977 +      typedef typename From::Arc Key;
   8.978 +      typedef typename To::Arc Value;
   8.979 +
   8.980 +      Value operator[](const Key& key) const {
   8.981 +        bool forward = 
   8.982 +          (from.direction(key) == 
   8.983 +           (node_ref[from.source(static_cast<const Edge&>(key))] == 
   8.984 +            to.source(edge_ref[static_cast<const Edge&>(key)])));
   8.985 +	return to.direct(edge_ref[key], forward); 
   8.986 +      }
   8.987 +      
   8.988 +      const To& to;
   8.989 +      const From& from;
   8.990 +      const EdgeRefMap& edge_ref;
   8.991 +      const NodeRefMap& node_ref;
   8.992 +    };
   8.993 +
   8.994 +    
   8.995 +  public: 
   8.996 +
   8.997 +
   8.998 +    /// \brief Constructor for the DigraphCopy.
   8.999 +    ///
  8.1000 +    /// It copies the content of the \c _from digraph into the
  8.1001 +    /// \c _to digraph.
  8.1002 +    GraphCopy(To& _to, const From& _from) 
  8.1003 +      : from(_from), to(_to) {}
  8.1004 +
  8.1005 +    /// \brief Destructor of the DigraphCopy
  8.1006 +    ///
  8.1007 +    /// Destructor of the DigraphCopy
  8.1008 +    ~GraphCopy() {
  8.1009 +      for (int i = 0; i < int(nodeMapCopies.size()); ++i) {
  8.1010 +        delete nodeMapCopies[i];
  8.1011 +      }
  8.1012 +      for (int i = 0; i < int(arcMapCopies.size()); ++i) {
  8.1013 +        delete arcMapCopies[i];
  8.1014 +      }
  8.1015 +      for (int i = 0; i < int(edgeMapCopies.size()); ++i) {
  8.1016 +        delete edgeMapCopies[i];
  8.1017 +      }
  8.1018 +
  8.1019 +    }
  8.1020 +
  8.1021 +    /// \brief Copies the node references into the given map.
  8.1022 +    ///
  8.1023 +    /// Copies the node references into the given map.
  8.1024 +    template <typename NodeRef>
  8.1025 +    GraphCopy& nodeRef(NodeRef& map) {
  8.1026 +      nodeMapCopies.push_back(new _digraph_utils_bits::RefCopy<From, Node, 
  8.1027 +                              NodeRefMap, NodeRef>(map));
  8.1028 +      return *this;
  8.1029 +    }
  8.1030 +
  8.1031 +    /// \brief Copies the node cross references into the given map.
  8.1032 +    ///
  8.1033 +    ///  Copies the node cross references (reverse references) into
  8.1034 +    ///  the given map.
  8.1035 +    template <typename NodeCrossRef>
  8.1036 +    GraphCopy& nodeCrossRef(NodeCrossRef& map) {
  8.1037 +      nodeMapCopies.push_back(new _digraph_utils_bits::CrossRefCopy<From, Node,
  8.1038 +                              NodeRefMap, NodeCrossRef>(map));
  8.1039 +      return *this;
  8.1040 +    }
  8.1041 +
  8.1042 +    /// \brief Make copy of the given map.
  8.1043 +    ///
  8.1044 +    /// Makes copy of the given map for the newly created digraph. 
  8.1045 +    /// The new map's key type is the to digraph's node type,
  8.1046 +    /// and the copied map's key type is the from digraph's node
  8.1047 +    /// type.  
  8.1048 +    template <typename ToMap, typename FromMap>
  8.1049 +    GraphCopy& nodeMap(ToMap& tmap, const FromMap& map) {
  8.1050 +      nodeMapCopies.push_back(new _digraph_utils_bits::MapCopy<From, Node, 
  8.1051 +                              NodeRefMap, ToMap, FromMap>(tmap, map));
  8.1052 +      return *this;
  8.1053 +    }
  8.1054 +
  8.1055 +    /// \brief Make a copy of the given node.
  8.1056 +    ///
  8.1057 +    /// Make a copy of the given node.
  8.1058 +    GraphCopy& node(TNode& tnode, const Node& snode) {
  8.1059 +      nodeMapCopies.push_back(new _digraph_utils_bits::ItemCopy<From, Node, 
  8.1060 +                              NodeRefMap, TNode>(tnode, snode));
  8.1061 +      return *this;
  8.1062 +    }
  8.1063 +
  8.1064 +    /// \brief Copies the arc references into the given map.
  8.1065 +    ///
  8.1066 +    /// Copies the arc references into the given map.
  8.1067 +    template <typename ArcRef>
  8.1068 +    GraphCopy& arcRef(ArcRef& map) {
  8.1069 +      arcMapCopies.push_back(new _digraph_utils_bits::RefCopy<From, Arc, 
  8.1070 +                              ArcRefMap, ArcRef>(map));
  8.1071 +      return *this;
  8.1072 +    }
  8.1073 +
  8.1074 +    /// \brief Copies the arc cross references into the given map.
  8.1075 +    ///
  8.1076 +    ///  Copies the arc cross references (reverse references) into
  8.1077 +    ///  the given map.
  8.1078 +    template <typename ArcCrossRef>
  8.1079 +    GraphCopy& arcCrossRef(ArcCrossRef& map) {
  8.1080 +      arcMapCopies.push_back(new _digraph_utils_bits::CrossRefCopy<From, Arc,
  8.1081 +                              ArcRefMap, ArcCrossRef>(map));
  8.1082 +      return *this;
  8.1083 +    }
  8.1084 +
  8.1085 +    /// \brief Make copy of the given map.
  8.1086 +    ///
  8.1087 +    /// Makes copy of the given map for the newly created digraph. 
  8.1088 +    /// The new map's key type is the to digraph's arc type,
  8.1089 +    /// and the copied map's key type is the from digraph's arc
  8.1090 +    /// type.  
  8.1091 +    template <typename ToMap, typename FromMap>
  8.1092 +    GraphCopy& arcMap(ToMap& tmap, const FromMap& map) {
  8.1093 +      arcMapCopies.push_back(new _digraph_utils_bits::MapCopy<From, Arc, 
  8.1094 +                              ArcRefMap, ToMap, FromMap>(tmap, map));
  8.1095 +      return *this;
  8.1096 +    }
  8.1097 +
  8.1098 +    /// \brief Make a copy of the given arc.
  8.1099 +    ///
  8.1100 +    /// Make a copy of the given arc.
  8.1101 +    GraphCopy& arc(TArc& tarc, const Arc& sarc) {
  8.1102 +      arcMapCopies.push_back(new _digraph_utils_bits::ItemCopy<From, Arc, 
  8.1103 +                              ArcRefMap, TArc>(tarc, sarc));
  8.1104 +      return *this;
  8.1105 +    }
  8.1106 +
  8.1107 +    /// \brief Copies the edge references into the given map.
  8.1108 +    ///
  8.1109 +    /// Copies the edge references into the given map.
  8.1110 +    template <typename EdgeRef>
  8.1111 +    GraphCopy& edgeRef(EdgeRef& map) {
  8.1112 +      edgeMapCopies.push_back(new _digraph_utils_bits::RefCopy<From, Edge, 
  8.1113 +                               EdgeRefMap, EdgeRef>(map));
  8.1114 +      return *this;
  8.1115 +    }
  8.1116 +
  8.1117 +    /// \brief Copies the edge cross references into the given map.
  8.1118 +    ///
  8.1119 +    /// Copies the edge cross references (reverse
  8.1120 +    /// references) into the given map.
  8.1121 +    template <typename EdgeCrossRef>
  8.1122 +    GraphCopy& edgeCrossRef(EdgeCrossRef& map) {
  8.1123 +      edgeMapCopies.push_back(new _digraph_utils_bits::CrossRefCopy<From, 
  8.1124 +                               Edge, EdgeRefMap, EdgeCrossRef>(map));
  8.1125 +      return *this;
  8.1126 +    }
  8.1127 +
  8.1128 +    /// \brief Make copy of the given map.
  8.1129 +    ///
  8.1130 +    /// Makes copy of the given map for the newly created digraph. 
  8.1131 +    /// The new map's key type is the to digraph's edge type,
  8.1132 +    /// and the copied map's key type is the from digraph's edge
  8.1133 +    /// type.  
  8.1134 +    template <typename ToMap, typename FromMap>
  8.1135 +    GraphCopy& edgeMap(ToMap& tmap, const FromMap& map) {
  8.1136 +      edgeMapCopies.push_back(new _digraph_utils_bits::MapCopy<From, Edge, 
  8.1137 +                               EdgeRefMap, ToMap, FromMap>(tmap, map));
  8.1138 +      return *this;
  8.1139 +    }
  8.1140 +
  8.1141 +    /// \brief Make a copy of the given edge.
  8.1142 +    ///
  8.1143 +    /// Make a copy of the given edge.
  8.1144 +    GraphCopy& edge(TEdge& tedge, const Edge& sedge) {
  8.1145 +      edgeMapCopies.push_back(new _digraph_utils_bits::ItemCopy<From, Edge, 
  8.1146 +                               EdgeRefMap, TEdge>(tedge, sedge));
  8.1147 +      return *this;
  8.1148 +    }
  8.1149 +
  8.1150 +    /// \brief Executes the copies.
  8.1151 +    ///
  8.1152 +    /// Executes the copies.
  8.1153 +    void run() {
  8.1154 +      NodeRefMap nodeRefMap(from);
  8.1155 +      EdgeRefMap edgeRefMap(from);
  8.1156 +      ArcRefMap arcRefMap(to, from, edgeRefMap, nodeRefMap);
  8.1157 +      _digraph_utils_bits::GraphCopySelector<To>::
  8.1158 +        copy(to, from, nodeRefMap, edgeRefMap);
  8.1159 +      for (int i = 0; i < int(nodeMapCopies.size()); ++i) {
  8.1160 +        nodeMapCopies[i]->copy(from, nodeRefMap);
  8.1161 +      }
  8.1162 +      for (int i = 0; i < int(edgeMapCopies.size()); ++i) {
  8.1163 +        edgeMapCopies[i]->copy(from, edgeRefMap);
  8.1164 +      }
  8.1165 +      for (int i = 0; i < int(arcMapCopies.size()); ++i) {
  8.1166 +        arcMapCopies[i]->copy(from, arcRefMap);
  8.1167 +      }
  8.1168 +    }
  8.1169 +
  8.1170 +  private:
  8.1171 +    
  8.1172 +    const From& from;
  8.1173 +    To& to;
  8.1174 +
  8.1175 +    std::vector<_digraph_utils_bits::MapCopyBase<From, Node, NodeRefMap>* > 
  8.1176 +    nodeMapCopies;
  8.1177 +
  8.1178 +    std::vector<_digraph_utils_bits::MapCopyBase<From, Arc, ArcRefMap>* > 
  8.1179 +    arcMapCopies;
  8.1180 +
  8.1181 +    std::vector<_digraph_utils_bits::MapCopyBase<From, Edge, EdgeRefMap>* > 
  8.1182 +    edgeMapCopies;
  8.1183 +
  8.1184 +  };
  8.1185 +
  8.1186 +  /// \brief Copy an graph to another digraph.
  8.1187 +  ///
  8.1188 +  /// Copy an graph to another digraph.
  8.1189 +  /// The usage of the function:
  8.1190 +  /// 
  8.1191 +  ///\code
  8.1192 +  /// copyGraph(trg, src).nodeRef(nr).arcCrossRef(ecr).run();
  8.1193 +  ///\endcode
  8.1194 +  /// 
  8.1195 +  /// After the copy the \c nr map will contain the mapping from the
  8.1196 +  /// nodes of the \c from digraph to the nodes of the \c to digraph and
  8.1197 +  /// \c ecr will contain the mapping from the arcs of the \c to digraph
  8.1198 +  /// to the arcs of the \c from digraph.
  8.1199 +  ///
  8.1200 +  /// \see GraphCopy 
  8.1201 +  template <typename To, typename From>
  8.1202 +  GraphCopy<To, From> 
  8.1203 +  copyGraph(To& to, const From& from) {
  8.1204 +    return GraphCopy<To, From>(to, from);
  8.1205 +  }
  8.1206 +
  8.1207 +  /// \brief Class to copy a bipartite digraph.
  8.1208 +  ///
  8.1209 +  /// Class to copy a bipartite digraph to another digraph
  8.1210 +  /// (duplicate a digraph).  The simplest way of using it is through
  8.1211 +  /// the \c copyBpGraph() function.
  8.1212 +  template <typename To, typename From>
  8.1213 +  class BpGraphCopy {
  8.1214 +  private:
  8.1215 +
  8.1216 +    typedef typename From::Node Node;
  8.1217 +    typedef typename From::Red Red;
  8.1218 +    typedef typename From::Blue Blue;
  8.1219 +    typedef typename From::NodeIt NodeIt;
  8.1220 +    typedef typename From::Arc Arc;
  8.1221 +    typedef typename From::ArcIt ArcIt;
  8.1222 +    typedef typename From::Edge Edge;
  8.1223 +    typedef typename From::EdgeIt EdgeIt;
  8.1224 +
  8.1225 +    typedef typename To::Node TNode;
  8.1226 +    typedef typename To::Arc TArc;
  8.1227 +    typedef typename To::Edge TEdge;
  8.1228 +
  8.1229 +    typedef typename From::template RedMap<TNode> RedRefMap;
  8.1230 +    typedef typename From::template BlueMap<TNode> BlueRefMap;
  8.1231 +    typedef typename From::template EdgeMap<TEdge> EdgeRefMap;
  8.1232 +
  8.1233 +    struct NodeRefMap {
  8.1234 +      NodeRefMap(const From& _from, const RedRefMap& _red_ref,
  8.1235 +                 const BlueRefMap& _blue_ref)
  8.1236 +        : from(_from), red_ref(_red_ref), blue_ref(_blue_ref) {}
  8.1237 +
  8.1238 +      typedef typename From::Node Key;
  8.1239 +      typedef typename To::Node Value;
  8.1240 +
  8.1241 +      Value operator[](const Key& key) const {
  8.1242 +	return from.red(key) ? red_ref[key] : blue_ref[key]; 
  8.1243 +      }
  8.1244 +      
  8.1245 +      const From& from;
  8.1246 +      const RedRefMap& red_ref;
  8.1247 +      const BlueRefMap& blue_ref;
  8.1248 +    };
  8.1249 +
  8.1250 +    struct ArcRefMap {
  8.1251 +      ArcRefMap(const To& _to, const From& _from,
  8.1252 +                 const EdgeRefMap& _edge_ref, const NodeRefMap& _node_ref) 
  8.1253 +        : to(_to), from(_from), 
  8.1254 +          edge_ref(_edge_ref), node_ref(_node_ref) {}
  8.1255 +
  8.1256 +      typedef typename From::Arc Key;
  8.1257 +      typedef typename To::Arc Value;
  8.1258 +
  8.1259 +      Value operator[](const Key& key) const {
  8.1260 +        bool forward = 
  8.1261 +          (from.direction(key) == 
  8.1262 +           (node_ref[from.source(static_cast<const Edge&>(key))] == 
  8.1263 +            to.source(edge_ref[static_cast<const Edge&>(key)])));
  8.1264 +	return to.direct(edge_ref[key], forward); 
  8.1265 +      }
  8.1266 +      
  8.1267 +      const To& to;
  8.1268 +      const From& from;
  8.1269 +      const EdgeRefMap& edge_ref;
  8.1270 +      const NodeRefMap& node_ref;
  8.1271 +    };
  8.1272 +    
  8.1273 +  public: 
  8.1274 +
  8.1275 +
  8.1276 +    /// \brief Constructor for the DigraphCopy.
  8.1277 +    ///
  8.1278 +    /// It copies the content of the \c _from digraph into the
  8.1279 +    /// \c _to digraph.
  8.1280 +    BpGraphCopy(To& _to, const From& _from) 
  8.1281 +      : from(_from), to(_to) {}
  8.1282 +
  8.1283 +    /// \brief Destructor of the DigraphCopy
  8.1284 +    ///
  8.1285 +    /// Destructor of the DigraphCopy
  8.1286 +    ~BpGraphCopy() {
  8.1287 +      for (int i = 0; i < int(redMapCopies.size()); ++i) {
  8.1288 +        delete redMapCopies[i];
  8.1289 +      }
  8.1290 +      for (int i = 0; i < int(blueMapCopies.size()); ++i) {
  8.1291 +        delete blueMapCopies[i];
  8.1292 +      }
  8.1293 +      for (int i = 0; i < int(nodeMapCopies.size()); ++i) {
  8.1294 +        delete nodeMapCopies[i];
  8.1295 +      }
  8.1296 +      for (int i = 0; i < int(arcMapCopies.size()); ++i) {
  8.1297 +        delete arcMapCopies[i];
  8.1298 +      }
  8.1299 +      for (int i = 0; i < int(edgeMapCopies.size()); ++i) {
  8.1300 +        delete edgeMapCopies[i];
  8.1301 +      }
  8.1302 +
  8.1303 +    }
  8.1304 +
  8.1305 +    /// \brief Copies the A-node references into the given map.
  8.1306 +    ///
  8.1307 +    /// Copies the A-node references into the given map.
  8.1308 +    template <typename RedRef>
  8.1309 +    BpGraphCopy& redRef(RedRef& map) {
  8.1310 +      redMapCopies.push_back(new _digraph_utils_bits::RefCopy<From, Red, 
  8.1311 +                               RedRefMap, RedRef>(map));
  8.1312 +      return *this;
  8.1313 +    }
  8.1314 +
  8.1315 +    /// \brief Copies the A-node cross references into the given map.
  8.1316 +    ///
  8.1317 +    /// Copies the A-node cross references (reverse references) into
  8.1318 +    /// the given map.
  8.1319 +    template <typename RedCrossRef>
  8.1320 +    BpGraphCopy& redCrossRef(RedCrossRef& map) {
  8.1321 +      redMapCopies.push_back(new _digraph_utils_bits::CrossRefCopy<From, 
  8.1322 +                               Red, RedRefMap, RedCrossRef>(map));
  8.1323 +      return *this;
  8.1324 +    }
  8.1325 +
  8.1326 +    /// \brief Make copy of the given A-node map.
  8.1327 +    ///
  8.1328 +    /// Makes copy of the given map for the newly created digraph. 
  8.1329 +    /// The new map's key type is the to digraph's node type,
  8.1330 +    /// and the copied map's key type is the from digraph's node
  8.1331 +    /// type.  
  8.1332 +    template <typename ToMap, typename FromMap>
  8.1333 +    BpGraphCopy& redMap(ToMap& tmap, const FromMap& map) {
  8.1334 +      redMapCopies.push_back(new _digraph_utils_bits::MapCopy<From, Red, 
  8.1335 +                               RedRefMap, ToMap, FromMap>(tmap, map));
  8.1336 +      return *this;
  8.1337 +    }
  8.1338 +
  8.1339 +    /// \brief Copies the B-node references into the given map.
  8.1340 +    ///
  8.1341 +    /// Copies the B-node references into the given map.
  8.1342 +    template <typename BlueRef>
  8.1343 +    BpGraphCopy& blueRef(BlueRef& map) {
  8.1344 +      blueMapCopies.push_back(new _digraph_utils_bits::RefCopy<From, Blue, 
  8.1345 +                               BlueRefMap, BlueRef>(map));
  8.1346 +      return *this;
  8.1347 +    }
  8.1348 +
  8.1349 +    /// \brief Copies the B-node cross references into the given map.
  8.1350 +    ///
  8.1351 +    ///  Copies the B-node cross references (reverse references) into
  8.1352 +    ///  the given map.
  8.1353 +    template <typename BlueCrossRef>
  8.1354 +    BpGraphCopy& blueCrossRef(BlueCrossRef& map) {
  8.1355 +      blueMapCopies.push_back(new _digraph_utils_bits::CrossRefCopy<From, 
  8.1356 +                              Blue, BlueRefMap, BlueCrossRef>(map));
  8.1357 +      return *this;
  8.1358 +    }
  8.1359 +
  8.1360 +    /// \brief Make copy of the given B-node map.
  8.1361 +    ///
  8.1362 +    /// Makes copy of the given map for the newly created digraph. 
  8.1363 +    /// The new map's key type is the to digraph's node type,
  8.1364 +    /// and the copied map's key type is the from digraph's node
  8.1365 +    /// type.  
  8.1366 +    template <typename ToMap, typename FromMap>
  8.1367 +    BpGraphCopy& blueMap(ToMap& tmap, const FromMap& map) {
  8.1368 +      blueMapCopies.push_back(new _digraph_utils_bits::MapCopy<From, Blue, 
  8.1369 +                               BlueRefMap, ToMap, FromMap>(tmap, map));
  8.1370 +      return *this;
  8.1371 +    }
  8.1372 +    /// \brief Copies the node references into the given map.
  8.1373 +    ///
  8.1374 +    /// Copies the node references into the given map.
  8.1375 +    template <typename NodeRef>
  8.1376 +    BpGraphCopy& nodeRef(NodeRef& map) {
  8.1377 +      nodeMapCopies.push_back(new _digraph_utils_bits::RefCopy<From, Node, 
  8.1378 +                              NodeRefMap, NodeRef>(map));
  8.1379 +      return *this;
  8.1380 +    }
  8.1381 +
  8.1382 +    /// \brief Copies the node cross references into the given map.
  8.1383 +    ///
  8.1384 +    ///  Copies the node cross references (reverse references) into
  8.1385 +    ///  the given map.
  8.1386 +    template <typename NodeCrossRef>
  8.1387 +    BpGraphCopy& nodeCrossRef(NodeCrossRef& map) {
  8.1388 +      nodeMapCopies.push_back(new _digraph_utils_bits::CrossRefCopy<From, Node,
  8.1389 +                              NodeRefMap, NodeCrossRef>(map));
  8.1390 +      return *this;
  8.1391 +    }
  8.1392 +
  8.1393 +    /// \brief Make copy of the given map.
  8.1394 +    ///
  8.1395 +    /// Makes copy of the given map for the newly created digraph. 
  8.1396 +    /// The new map's key type is the to digraph's node type,
  8.1397 +    /// and the copied map's key type is the from digraph's node
  8.1398 +    /// type.  
  8.1399 +    template <typename ToMap, typename FromMap>
  8.1400 +    BpGraphCopy& nodeMap(ToMap& tmap, const FromMap& map) {
  8.1401 +      nodeMapCopies.push_back(new _digraph_utils_bits::MapCopy<From, Node, 
  8.1402 +                              NodeRefMap, ToMap, FromMap>(tmap, map));
  8.1403 +      return *this;
  8.1404 +    }
  8.1405 +
  8.1406 +    /// \brief Make a copy of the given node.
  8.1407 +    ///
  8.1408 +    /// Make a copy of the given node.
  8.1409 +    BpGraphCopy& node(TNode& tnode, const Node& snode) {
  8.1410 +      nodeMapCopies.push_back(new _digraph_utils_bits::ItemCopy<From, Node, 
  8.1411 +                              NodeRefMap, TNode>(tnode, snode));
  8.1412 +      return *this;
  8.1413 +    }
  8.1414 +
  8.1415 +    /// \brief Copies the arc references into the given map.
  8.1416 +    ///
  8.1417 +    /// Copies the arc references into the given map.
  8.1418 +    template <typename ArcRef>
  8.1419 +    BpGraphCopy& arcRef(ArcRef& map) {
  8.1420 +      arcMapCopies.push_back(new _digraph_utils_bits::RefCopy<From, Arc, 
  8.1421 +                              ArcRefMap, ArcRef>(map));
  8.1422 +      return *this;
  8.1423 +    }
  8.1424 +
  8.1425 +    /// \brief Copies the arc cross references into the given map.
  8.1426 +    ///
  8.1427 +    ///  Copies the arc cross references (reverse references) into
  8.1428 +    ///  the given map.
  8.1429 +    template <typename ArcCrossRef>
  8.1430 +    BpGraphCopy& arcCrossRef(ArcCrossRef& map) {
  8.1431 +      arcMapCopies.push_back(new _digraph_utils_bits::CrossRefCopy<From, Arc,
  8.1432 +                              ArcRefMap, ArcCrossRef>(map));
  8.1433 +      return *this;
  8.1434 +    }
  8.1435 +
  8.1436 +    /// \brief Make copy of the given map.
  8.1437 +    ///
  8.1438 +    /// Makes copy of the given map for the newly created digraph. 
  8.1439 +    /// The new map's key type is the to digraph's arc type,
  8.1440 +    /// and the copied map's key type is the from digraph's arc
  8.1441 +    /// type.  
  8.1442 +    template <typename ToMap, typename FromMap>
  8.1443 +    BpGraphCopy& arcMap(ToMap& tmap, const FromMap& map) {
  8.1444 +      arcMapCopies.push_back(new _digraph_utils_bits::MapCopy<From, Arc, 
  8.1445 +                              ArcRefMap, ToMap, FromMap>(tmap, map));
  8.1446 +      return *this;
  8.1447 +    }
  8.1448 +
  8.1449 +    /// \brief Make a copy of the given arc.
  8.1450 +    ///
  8.1451 +    /// Make a copy of the given arc.
  8.1452 +    BpGraphCopy& arc(TArc& tarc, const Arc& sarc) {
  8.1453 +      arcMapCopies.push_back(new _digraph_utils_bits::ItemCopy<From, Arc, 
  8.1454 +                              ArcRefMap, TArc>(tarc, sarc));
  8.1455 +      return *this;
  8.1456 +    }
  8.1457 +
  8.1458 +    /// \brief Copies the edge references into the given map.
  8.1459 +    ///
  8.1460 +    /// Copies the edge references into the given map.
  8.1461 +    template <typename EdgeRef>
  8.1462 +    BpGraphCopy& edgeRef(EdgeRef& map) {
  8.1463 +      edgeMapCopies.push_back(new _digraph_utils_bits::RefCopy<From, Edge, 
  8.1464 +                               EdgeRefMap, EdgeRef>(map));
  8.1465 +      return *this;
  8.1466 +    }
  8.1467 +
  8.1468 +    /// \brief Copies the edge cross references into the given map.
  8.1469 +    ///
  8.1470 +    /// Copies the edge cross references (reverse
  8.1471 +    /// references) into the given map.
  8.1472 +    template <typename EdgeCrossRef>
  8.1473 +    BpGraphCopy& edgeCrossRef(EdgeCrossRef& map) {
  8.1474 +      edgeMapCopies.push_back(new _digraph_utils_bits::CrossRefCopy<From, 
  8.1475 +                               Edge, EdgeRefMap, EdgeCrossRef>(map));
  8.1476 +      return *this;
  8.1477 +    }
  8.1478 +
  8.1479 +    /// \brief Make copy of the given map.
  8.1480 +    ///
  8.1481 +    /// Makes copy of the given map for the newly created digraph. 
  8.1482 +    /// The new map's key type is the to digraph's edge type,
  8.1483 +    /// and the copied map's key type is the from digraph's edge
  8.1484 +    /// type.  
  8.1485 +    template <typename ToMap, typename FromMap>
  8.1486 +    BpGraphCopy& edgeMap(ToMap& tmap, const FromMap& map) {
  8.1487 +      edgeMapCopies.push_back(new _digraph_utils_bits::MapCopy<From, Edge, 
  8.1488 +                               EdgeRefMap, ToMap, FromMap>(tmap, map));
  8.1489 +      return *this;
  8.1490 +    }
  8.1491 +
  8.1492 +    /// \brief Make a copy of the given edge.
  8.1493 +    ///
  8.1494 +    /// Make a copy of the given edge.
  8.1495 +    BpGraphCopy& edge(TEdge& tedge, const Edge& sedge) {
  8.1496 +      edgeMapCopies.push_back(new _digraph_utils_bits::ItemCopy<From, Edge, 
  8.1497 +                               EdgeRefMap, TEdge>(tedge, sedge));
  8.1498 +      return *this;
  8.1499 +    }
  8.1500 +
  8.1501 +    /// \brief Executes the copies.
  8.1502 +    ///
  8.1503 +    /// Executes the copies.
  8.1504 +    void run() {
  8.1505 +      RedRefMap redRefMap(from);
  8.1506 +      BlueRefMap blueRefMap(from);
  8.1507 +      NodeRefMap nodeRefMap(from, redRefMap, blueRefMap);
  8.1508 +      EdgeRefMap edgeRefMap(from);
  8.1509 +      ArcRefMap arcRefMap(to, from, edgeRefMap, nodeRefMap);
  8.1510 +      _digraph_utils_bits::BpGraphCopySelector<To>::
  8.1511 +        copy(to, from, redRefMap, blueRefMap, edgeRefMap);
  8.1512 +      for (int i = 0; i < int(redMapCopies.size()); ++i) {
  8.1513 +        redMapCopies[i]->copy(from, redRefMap);
  8.1514 +      }
  8.1515 +      for (int i = 0; i < int(blueMapCopies.size()); ++i) {
  8.1516 +        blueMapCopies[i]->copy(from, blueRefMap);
  8.1517 +      }
  8.1518 +      for (int i = 0; i < int(nodeMapCopies.size()); ++i) {
  8.1519 +        nodeMapCopies[i]->copy(from, nodeRefMap);
  8.1520 +      }
  8.1521 +      for (int i = 0; i < int(edgeMapCopies.size()); ++i) {
  8.1522 +        edgeMapCopies[i]->copy(from, edgeRefMap);
  8.1523 +      }
  8.1524 +      for (int i = 0; i < int(arcMapCopies.size()); ++i) {
  8.1525 +        arcMapCopies[i]->copy(from, arcRefMap);
  8.1526 +      }
  8.1527 +    }
  8.1528 +
  8.1529 +  private:
  8.1530 +    
  8.1531 +    const From& from;
  8.1532 +    To& to;
  8.1533 +
  8.1534 +    std::vector<_digraph_utils_bits::MapCopyBase<From, Red, RedRefMap>* > 
  8.1535 +    redMapCopies;
  8.1536 +
  8.1537 +    std::vector<_digraph_utils_bits::MapCopyBase<From, Blue, BlueRefMap>* > 
  8.1538 +    blueMapCopies;
  8.1539 +
  8.1540 +    std::vector<_digraph_utils_bits::MapCopyBase<From, Node, NodeRefMap>* > 
  8.1541 +    nodeMapCopies;
  8.1542 +
  8.1543 +    std::vector<_digraph_utils_bits::MapCopyBase<From, Arc, ArcRefMap>* > 
  8.1544 +    arcMapCopies;
  8.1545 +
  8.1546 +    std::vector<_digraph_utils_bits::MapCopyBase<From, Edge, EdgeRefMap>* > 
  8.1547 +    edgeMapCopies;
  8.1548 +
  8.1549 +  };
  8.1550 +
  8.1551 +  /// \brief Copy a bipartite digraph to another digraph.
  8.1552 +  ///
  8.1553 +  /// Copy a bipartite digraph to another digraph.
  8.1554 +  /// The usage of the function:
  8.1555 +  /// 
  8.1556 +  ///\code
  8.1557 +  /// copyBpGraph(trg, src).redRef(anr).arcCrossRef(ecr).run();
  8.1558 +  ///\endcode
  8.1559 +  /// 
  8.1560 +  /// After the copy the \c nr map will contain the mapping from the
  8.1561 +  /// nodes of the \c from digraph to the nodes of the \c to digraph and
  8.1562 +  /// \c ecr will contain the mapping from the arcs of the \c to digraph
  8.1563 +  /// to the arcs of the \c from digraph.
  8.1564 +  ///
  8.1565 +  /// \see BpGraphCopy
  8.1566 +  template <typename To, typename From>
  8.1567 +  BpGraphCopy<To, From> 
  8.1568 +  copyBpGraph(To& to, const From& from) {
  8.1569 +    return BpGraphCopy<To, From>(to, from);
  8.1570 +  }
  8.1571 +
  8.1572 +
  8.1573 +  /// @}
  8.1574 +
  8.1575 +  /// \addtogroup digraph_maps
  8.1576 +  /// @{
  8.1577 +
  8.1578 +  /// Provides an immutable and unique id for each item in the digraph.
  8.1579 +
  8.1580 +  /// The IdMap class provides a unique and immutable id for each item of the
  8.1581 +  /// same type (e.g. node) in the digraph. This id is <ul><li>\b unique:
  8.1582 +  /// different items (nodes) get different ids <li>\b immutable: the id of an
  8.1583 +  /// item (node) does not change (even if you delete other nodes).  </ul>
  8.1584 +  /// Through this map you get access (i.e. can read) the inner id values of
  8.1585 +  /// the items stored in the digraph. This map can be inverted with its member
  8.1586 +  /// class \c InverseMap.
  8.1587 +  ///
  8.1588 +  template <typename _Digraph, typename _Item>
  8.1589 +  class IdMap {
  8.1590 +  public:
  8.1591 +    typedef _Digraph Digraph;
  8.1592 +    typedef int Value;
  8.1593 +    typedef _Item Item;
  8.1594 +    typedef _Item Key;
  8.1595 +
  8.1596 +    /// \brief Constructor.
  8.1597 +    ///
  8.1598 +    /// Constructor of the map.
  8.1599 +    explicit IdMap(const Digraph& _digraph) : digraph(&_digraph) {}
  8.1600 +
  8.1601 +    /// \brief Gives back the \e id of the item.
  8.1602 +    ///
  8.1603 +    /// Gives back the immutable and unique \e id of the item.
  8.1604 +    int operator[](const Item& item) const { return digraph->id(item);}
  8.1605 +
  8.1606 +    /// \brief Gives back the item by its id.
  8.1607 +    ///
  8.1608 +    /// Gives back the item by its id.
  8.1609 +    Item operator()(int id) { return digraph->fromId(id, Item()); }
  8.1610 +
  8.1611 +  private:
  8.1612 +    const Digraph* digraph;
  8.1613 +
  8.1614 +  public:
  8.1615 +
  8.1616 +    /// \brief The class represents the inverse of its owner (IdMap).
  8.1617 +    ///
  8.1618 +    /// The class represents the inverse of its owner (IdMap).
  8.1619 +    /// \see inverse()
  8.1620 +    class InverseMap {
  8.1621 +    public:
  8.1622 +
  8.1623 +      /// \brief Constructor.
  8.1624 +      ///
  8.1625 +      /// Constructor for creating an id-to-item map.
  8.1626 +      explicit InverseMap(const Digraph& _digraph) : digraph(&_digraph) {}
  8.1627 +
  8.1628 +      /// \brief Constructor.
  8.1629 +      ///
  8.1630 +      /// Constructor for creating an id-to-item map.
  8.1631 +      explicit InverseMap(const IdMap& idMap) : digraph(idMap.digraph) {}
  8.1632 +
  8.1633 +      /// \brief Gives back the given item from its id.
  8.1634 +      ///
  8.1635 +      /// Gives back the given item from its id.
  8.1636 +      /// 
  8.1637 +      Item operator[](int id) const { return digraph->fromId(id, Item());}
  8.1638 +
  8.1639 +    private:
  8.1640 +      const Digraph* digraph;
  8.1641 +    };
  8.1642 +
  8.1643 +    /// \brief Gives back the inverse of the map.
  8.1644 +    ///
  8.1645 +    /// Gives back the inverse of the IdMap.
  8.1646 +    InverseMap inverse() const { return InverseMap(*digraph);} 
  8.1647 +
  8.1648 +  };
  8.1649 +
  8.1650 +  
  8.1651 +  /// \brief General invertable digraph-map type.
  8.1652 +
  8.1653 +  /// This type provides simple invertable digraph-maps. 
  8.1654 +  /// The InvertableMap wraps an arbitrary ReadWriteMap 
  8.1655 +  /// and if a key is set to a new value then store it
  8.1656 +  /// in the inverse map.
  8.1657 +  ///
  8.1658 +  /// The values of the map can be accessed
  8.1659 +  /// with stl compatible forward iterator.
  8.1660 +  ///
  8.1661 +  /// \param _Digraph The digraph type.
  8.1662 +  /// \param _Item The item type of the digraph.
  8.1663 +  /// \param _Value The value type of the map.
  8.1664 +  ///
  8.1665 +  /// \see IterableValueMap
  8.1666 +  template <typename _Digraph, typename _Item, typename _Value>
  8.1667 +  class InvertableMap : protected DefaultMap<_Digraph, _Item, _Value> {
  8.1668 +  private:
  8.1669 +    
  8.1670 +    typedef DefaultMap<_Digraph, _Item, _Value> Map;
  8.1671 +    typedef _Digraph Digraph;
  8.1672 +
  8.1673 +    typedef std::map<_Value, _Item> Container;
  8.1674 +    Container invMap;    
  8.1675 +
  8.1676 +  public:
  8.1677 + 
  8.1678 +    /// The key type of InvertableMap (Node, Arc, Edge).
  8.1679 +    typedef typename Map::Key Key;
  8.1680 +    /// The value type of the InvertableMap.
  8.1681 +    typedef typename Map::Value Value;
  8.1682 +
  8.1683 +
  8.1684 +
  8.1685 +    /// \brief Constructor.
  8.1686 +    ///
  8.1687 +    /// Construct a new InvertableMap for the digraph.
  8.1688 +    ///
  8.1689 +    explicit InvertableMap(const Digraph& digraph) : Map(digraph) {} 
  8.1690 +
  8.1691 +    /// \brief Forward iterator for values.
  8.1692 +    ///
  8.1693 +    /// This iterator is an stl compatible forward
  8.1694 +    /// iterator on the values of the map. The values can
  8.1695 +    /// be accessed in the [beginValue, endValue) range.
  8.1696 +    ///
  8.1697 +    class ValueIterator 
  8.1698 +      : public std::iterator<std::forward_iterator_tag, Value> {
  8.1699 +      friend class InvertableMap;
  8.1700 +    private:
  8.1701 +      ValueIterator(typename Container::const_iterator _it) 
  8.1702 +        : it(_it) {}
  8.1703 +    public:
  8.1704 +      
  8.1705 +      ValueIterator() {}
  8.1706 +
  8.1707 +      ValueIterator& operator++() { ++it; return *this; }
  8.1708 +      ValueIterator operator++(int) { 
  8.1709 +        ValueIterator tmp(*this); 
  8.1710 +        operator++();
  8.1711 +        return tmp; 
  8.1712 +      }
  8.1713 +
  8.1714 +      const Value& operator*() const { return it->first; }
  8.1715 +      const Value* operator->() const { return &(it->first); }
  8.1716 +
  8.1717 +      bool operator==(ValueIterator jt) const { return it == jt.it; }
  8.1718 +      bool operator!=(ValueIterator jt) const { return it != jt.it; }
  8.1719 +      
  8.1720 +    private:
  8.1721 +      typename Container::const_iterator it;
  8.1722 +    };
  8.1723 +
  8.1724 +    /// \brief Returns an iterator to the first value.
  8.1725 +    ///
  8.1726 +    /// Returns an stl compatible iterator to the 
  8.1727 +    /// first value of the map. The values of the
  8.1728 +    /// map can be accessed in the [beginValue, endValue)
  8.1729 +    /// range.
  8.1730 +    ValueIterator beginValue() const {
  8.1731 +      return ValueIterator(invMap.begin());
  8.1732 +    }
  8.1733 +
  8.1734 +    /// \brief Returns an iterator after the last value.
  8.1735 +    ///
  8.1736 +    /// Returns an stl compatible iterator after the 
  8.1737 +    /// last value of the map. The values of the
  8.1738 +    /// map can be accessed in the [beginValue, endValue)
  8.1739 +    /// range.
  8.1740 +    ValueIterator endValue() const {
  8.1741 +      return ValueIterator(invMap.end());
  8.1742 +    }
  8.1743 +    
  8.1744 +    /// \brief The setter function of the map.
  8.1745 +    ///
  8.1746 +    /// Sets the mapped value.
  8.1747 +    void set(const Key& key, const Value& val) {
  8.1748 +      Value oldval = Map::operator[](key);
  8.1749 +      typename Container::iterator it = invMap.find(oldval);
  8.1750 +      if (it != invMap.end() && it->second == key) {
  8.1751 +	invMap.erase(it);
  8.1752 +      }      
  8.1753 +      invMap.insert(make_pair(val, key));
  8.1754 +      Map::set(key, val);
  8.1755 +    }
  8.1756 +
  8.1757 +    /// \brief The getter function of the map.
  8.1758 +    ///
  8.1759 +    /// It gives back the value associated with the key.
  8.1760 +    typename MapTraits<Map>::ConstReturnValue 
  8.1761 +    operator[](const Key& key) const {
  8.1762 +      return Map::operator[](key);
  8.1763 +    }
  8.1764 +
  8.1765 +    /// \brief Gives back the item by its value.
  8.1766 +    ///
  8.1767 +    /// Gives back the item by its value.
  8.1768 +    Key operator()(const Value& key) const {
  8.1769 +      typename Container::const_iterator it = invMap.find(key);
  8.1770 +      return it != invMap.end() ? it->second : INVALID;
  8.1771 +    }
  8.1772 +
  8.1773 +  protected:
  8.1774 +
  8.1775 +    /// \brief Erase the key from the map.
  8.1776 +    ///
  8.1777 +    /// Erase the key to the map. It is called by the
  8.1778 +    /// \c AlterationNotifier.
  8.1779 +    virtual void erase(const Key& key) {
  8.1780 +      Value val = Map::operator[](key);
  8.1781 +      typename Container::iterator it = invMap.find(val);
  8.1782 +      if (it != invMap.end() && it->second == key) {
  8.1783 +	invMap.erase(it);
  8.1784 +      }
  8.1785 +      Map::erase(key);
  8.1786 +    }
  8.1787 +
  8.1788 +    /// \brief Erase more keys from the map.
  8.1789 +    ///
  8.1790 +    /// Erase more keys from the map. It is called by the
  8.1791 +    /// \c AlterationNotifier.
  8.1792 +    virtual void erase(const std::vector<Key>& keys) {
  8.1793 +      for (int i = 0; i < int(keys.size()); ++i) {
  8.1794 +	Value val = Map::operator[](keys[i]);
  8.1795 +	typename Container::iterator it = invMap.find(val);
  8.1796 +	if (it != invMap.end() && it->second == keys[i]) {
  8.1797 +	  invMap.erase(it);
  8.1798 +	}
  8.1799 +      }
  8.1800 +      Map::erase(keys);
  8.1801 +    }
  8.1802 +
  8.1803 +    /// \brief Clear the keys from the map and inverse map.
  8.1804 +    ///
  8.1805 +    /// Clear the keys from the map and inverse map. It is called by the
  8.1806 +    /// \c AlterationNotifier.
  8.1807 +    virtual void clear() {
  8.1808 +      invMap.clear();
  8.1809 +      Map::clear();
  8.1810 +    }
  8.1811 +
  8.1812 +  public:
  8.1813 +
  8.1814 +    /// \brief The inverse map type.
  8.1815 +    ///
  8.1816 +    /// The inverse of this map. The subscript operator of the map
  8.1817 +    /// gives back always the item what was last assigned to the value. 
  8.1818 +    class InverseMap {
  8.1819 +    public:
  8.1820 +      /// \brief Constructor of the InverseMap.
  8.1821 +      ///
  8.1822 +      /// Constructor of the InverseMap.
  8.1823 +      explicit InverseMap(const InvertableMap& _inverted) 
  8.1824 +        : inverted(_inverted) {}
  8.1825 +
  8.1826 +      /// The value type of the InverseMap.
  8.1827 +      typedef typename InvertableMap::Key Value;
  8.1828 +      /// The key type of the InverseMap.
  8.1829 +      typedef typename InvertableMap::Value Key; 
  8.1830 +
  8.1831 +      /// \brief Subscript operator. 
  8.1832 +      ///
  8.1833 +      /// Subscript operator. It gives back always the item 
  8.1834 +      /// what was last assigned to the value.
  8.1835 +      Value operator[](const Key& key) const {
  8.1836 +	return inverted(key);
  8.1837 +      }
  8.1838 +      
  8.1839 +    private:
  8.1840 +      const InvertableMap& inverted;
  8.1841 +    };
  8.1842 +
  8.1843 +    /// \brief It gives back the just readable inverse map.
  8.1844 +    ///
  8.1845 +    /// It gives back the just readable inverse map.
  8.1846 +    InverseMap inverse() const {
  8.1847 +      return InverseMap(*this);
  8.1848 +    } 
  8.1849 +
  8.1850 +
  8.1851 +    
  8.1852 +  };
  8.1853 +
  8.1854 +  /// \brief Provides a mutable, continuous and unique descriptor for each 
  8.1855 +  /// item in the digraph.
  8.1856 +  ///
  8.1857 +  /// The DescriptorMap class provides a unique and continuous (but mutable)
  8.1858 +  /// descriptor (id) for each item of the same type (e.g. node) in the
  8.1859 +  /// digraph. This id is <ul><li>\b unique: different items (nodes) get
  8.1860 +  /// different ids <li>\b continuous: the range of the ids is the set of
  8.1861 +  /// integers between 0 and \c n-1, where \c n is the number of the items of
  8.1862 +  /// this type (e.g. nodes) (so the id of a node can change if you delete an
  8.1863 +  /// other node, i.e. this id is mutable).  </ul> This map can be inverted
  8.1864 +  /// with its member class \c InverseMap.
  8.1865 +  ///
  8.1866 +  /// \param _Digraph The digraph class the \c DescriptorMap belongs to.
  8.1867 +  /// \param _Item The Item is the Key of the Map. It may be Node, Arc or 
  8.1868 +  /// Edge.
  8.1869 +  template <typename _Digraph, typename _Item>
  8.1870 +  class DescriptorMap : protected DefaultMap<_Digraph, _Item, int> {
  8.1871 +
  8.1872 +    typedef _Item Item;
  8.1873 +    typedef DefaultMap<_Digraph, _Item, int> Map;
  8.1874 +
  8.1875 +  public:
  8.1876 +    /// The digraph class of DescriptorMap.
  8.1877 +    typedef _Digraph Digraph;
  8.1878 +
  8.1879 +    /// The key type of DescriptorMap (Node, Arc, Edge).
  8.1880 +    typedef typename Map::Key Key;
  8.1881 +    /// The value type of DescriptorMap.
  8.1882 +    typedef typename Map::Value Value;
  8.1883 +
  8.1884 +    /// \brief Constructor.
  8.1885 +    ///
  8.1886 +    /// Constructor for descriptor map.
  8.1887 +    explicit DescriptorMap(const Digraph& _digraph) : Map(_digraph) {
  8.1888 +      Item it;
  8.1889 +      const typename Map::Notifier* nf = Map::notifier(); 
  8.1890 +      for (nf->first(it); it != INVALID; nf->next(it)) {
  8.1891 +	Map::set(it, invMap.size());
  8.1892 +	invMap.push_back(it);	
  8.1893 +      }      
  8.1894 +    }
  8.1895 +
  8.1896 +  protected:
  8.1897 +
  8.1898 +    /// \brief Add a new key to the map.
  8.1899 +    ///
  8.1900 +    /// Add a new key to the map. It is called by the
  8.1901 +    /// \c AlterationNotifier.
  8.1902 +    virtual void add(const Item& item) {
  8.1903 +      Map::add(item);
  8.1904 +      Map::set(item, invMap.size());
  8.1905 +      invMap.push_back(item);
  8.1906 +    }
  8.1907 +
  8.1908 +    /// \brief Add more new keys to the map.
  8.1909 +    ///
  8.1910 +    /// Add more new keys to the map. It is called by the
  8.1911 +    /// \c AlterationNotifier.
  8.1912 +    virtual void add(const std::vector<Item>& items) {
  8.1913 +      Map::add(items);
  8.1914 +      for (int i = 0; i < int(items.size()); ++i) {
  8.1915 +	Map::set(items[i], invMap.size());
  8.1916 +	invMap.push_back(items[i]);
  8.1917 +      }
  8.1918 +    }
  8.1919 +
  8.1920 +    /// \brief Erase the key from the map.
  8.1921 +    ///
  8.1922 +    /// Erase the key from the map. It is called by the
  8.1923 +    /// \c AlterationNotifier.
  8.1924 +    virtual void erase(const Item& item) {
  8.1925 +      Map::set(invMap.back(), Map::operator[](item));
  8.1926 +      invMap[Map::operator[](item)] = invMap.back();
  8.1927 +      invMap.pop_back();
  8.1928 +      Map::erase(item);
  8.1929 +    }
  8.1930 +
  8.1931 +    /// \brief Erase more keys from the map.
  8.1932 +    ///
  8.1933 +    /// Erase more keys from the map. It is called by the
  8.1934 +    /// \c AlterationNotifier.
  8.1935 +    virtual void erase(const std::vector<Item>& items) {
  8.1936 +      for (int i = 0; i < int(items.size()); ++i) {
  8.1937 +	Map::set(invMap.back(), Map::operator[](items[i]));
  8.1938 +	invMap[Map::operator[](items[i])] = invMap.back();
  8.1939 +	invMap.pop_back();
  8.1940 +      }
  8.1941 +      Map::erase(items);
  8.1942 +    }
  8.1943 +
  8.1944 +    /// \brief Build the unique map.
  8.1945 +    ///
  8.1946 +    /// Build the unique map. It is called by the
  8.1947 +    /// \c AlterationNotifier.
  8.1948 +    virtual void build() {
  8.1949 +      Map::build();
  8.1950 +      Item it;
  8.1951 +      const typename Map::Notifier* nf = Map::notifier(); 
  8.1952 +      for (nf->first(it); it != INVALID; nf->next(it)) {
  8.1953 +	Map::set(it, invMap.size());
  8.1954 +	invMap.push_back(it);	
  8.1955 +      }      
  8.1956 +    }
  8.1957 +    
  8.1958 +    /// \brief Clear the keys from the map.
  8.1959 +    ///
  8.1960 +    /// Clear the keys from the map. It is called by the
  8.1961 +    /// \c AlterationNotifier.
  8.1962 +    virtual void clear() {
  8.1963 +      invMap.clear();
  8.1964 +      Map::clear();
  8.1965 +    }
  8.1966 +
  8.1967 +  public:
  8.1968 +
  8.1969 +    /// \brief Returns the maximal value plus one.
  8.1970 +    ///
  8.1971 +    /// Returns the maximal value plus one in the map.
  8.1972 +    unsigned int size() const {
  8.1973 +      return invMap.size();
  8.1974 +    }
  8.1975 +
  8.1976 +    /// \brief Swaps the position of the two items in the map.
  8.1977 +    ///
  8.1978 +    /// Swaps the position of the two items in the map.
  8.1979 +    void swap(const Item& p, const Item& q) {
  8.1980 +      int pi = Map::operator[](p);
  8.1981 +      int qi = Map::operator[](q);
  8.1982 +      Map::set(p, qi);
  8.1983 +      invMap[qi] = p;
  8.1984 +      Map::set(q, pi);
  8.1985 +      invMap[pi] = q;
  8.1986 +    }
  8.1987 +
  8.1988 +    /// \brief Gives back the \e descriptor of the item.
  8.1989 +    ///
  8.1990 +    /// Gives back the mutable and unique \e descriptor of the map.
  8.1991 +    int operator[](const Item& item) const {
  8.1992 +      return Map::operator[](item);
  8.1993 +    }
  8.1994 +
  8.1995 +    /// \brief Gives back the item by its descriptor.
  8.1996 +    ///
  8.1997 +    /// Gives back th item by its descriptor.
  8.1998 +    Item operator()(int id) const {
  8.1999 +      return invMap[id];
  8.2000 +    }
  8.2001 +    
  8.2002 +  private:
  8.2003 +
  8.2004 +    typedef std::vector<Item> Container;
  8.2005 +    Container invMap;
  8.2006 +
  8.2007 +  public:
  8.2008 +    /// \brief The inverse map type of DescriptorMap.
  8.2009 +    ///
  8.2010 +    /// The inverse map type of DescriptorMap.
  8.2011 +    class InverseMap {
  8.2012 +    public:
  8.2013 +      /// \brief Constructor of the InverseMap.
  8.2014 +      ///
  8.2015 +      /// Constructor of the InverseMap.
  8.2016 +      explicit InverseMap(const DescriptorMap& _inverted) 
  8.2017 +	: inverted(_inverted) {}
  8.2018 +
  8.2019 +
  8.2020 +      /// The value type of the InverseMap.
  8.2021 +      typedef typename DescriptorMap::Key Value;
  8.2022 +      /// The key type of the InverseMap.
  8.2023 +      typedef typename DescriptorMap::Value Key; 
  8.2024 +
  8.2025 +      /// \brief Subscript operator. 
  8.2026 +      ///
  8.2027 +      /// Subscript operator. It gives back the item 
  8.2028 +      /// that the descriptor belongs to currently.
  8.2029 +      Value operator[](const Key& key) const {
  8.2030 +	return inverted(key);
  8.2031 +      }
  8.2032 +
  8.2033 +      /// \brief Size of the map.
  8.2034 +      ///
  8.2035 +      /// Returns the size of the map.
  8.2036 +      unsigned int size() const {
  8.2037 +	return inverted.size();
  8.2038 +      }
  8.2039 +      
  8.2040 +    private:
  8.2041 +      const DescriptorMap& inverted;
  8.2042 +    };
  8.2043 +
  8.2044 +    /// \brief Gives back the inverse of the map.
  8.2045 +    ///
  8.2046 +    /// Gives back the inverse of the map.
  8.2047 +    const InverseMap inverse() const {
  8.2048 +      return InverseMap(*this);
  8.2049 +    }
  8.2050 +  };
  8.2051 +
  8.2052 +  /// \brief Returns the source of the given arc.
  8.2053 +  ///
  8.2054 +  /// The SourceMap gives back the source Node of the given arc. 
  8.2055 +  /// \see TargetMap
  8.2056 +  /// \author Balazs Dezso
  8.2057 +  template <typename Digraph>
  8.2058 +  class SourceMap {
  8.2059 +  public:
  8.2060 +
  8.2061 +    typedef typename Digraph::Node Value;
  8.2062 +    typedef typename Digraph::Arc Key;
  8.2063 +
  8.2064 +    /// \brief Constructor
  8.2065 +    ///
  8.2066 +    /// Constructor
  8.2067 +    /// \param _digraph The digraph that the map belongs to.
  8.2068 +    explicit SourceMap(const Digraph& _digraph) : digraph(_digraph) {}
  8.2069 +
  8.2070 +    /// \brief The subscript operator.
  8.2071 +    ///
  8.2072 +    /// The subscript operator.
  8.2073 +    /// \param arc The arc 
  8.2074 +    /// \return The source of the arc 
  8.2075 +    Value operator[](const Key& arc) const {
  8.2076 +      return digraph.source(arc);
  8.2077 +    }
  8.2078 +
  8.2079 +  private:
  8.2080 +    const Digraph& digraph;
  8.2081 +  };
  8.2082 +
  8.2083 +  /// \brief Returns a \ref SourceMap class.
  8.2084 +  ///
  8.2085 +  /// This function just returns an \ref SourceMap class.
  8.2086 +  /// \relates SourceMap
  8.2087 +  template <typename Digraph>
  8.2088 +  inline SourceMap<Digraph> sourceMap(const Digraph& digraph) {
  8.2089 +    return SourceMap<Digraph>(digraph);
  8.2090 +  } 
  8.2091 +
  8.2092 +  /// \brief Returns the target of the given arc.
  8.2093 +  ///
  8.2094 +  /// The TargetMap gives back the target Node of the given arc. 
  8.2095 +  /// \see SourceMap
  8.2096 +  /// \author Balazs Dezso
  8.2097 +  template <typename Digraph>
  8.2098 +  class TargetMap {
  8.2099 +  public:
  8.2100 +
  8.2101 +    typedef typename Digraph::Node Value;
  8.2102 +    typedef typename Digraph::Arc Key;
  8.2103 +
  8.2104 +    /// \brief Constructor
  8.2105 +    ///
  8.2106 +    /// Constructor
  8.2107 +    /// \param _digraph The digraph that the map belongs to.
  8.2108 +    explicit TargetMap(const Digraph& _digraph) : digraph(_digraph) {}
  8.2109 +
  8.2110 +    /// \brief The subscript operator.
  8.2111 +    ///
  8.2112 +    /// The subscript operator.
  8.2113 +    /// \param e The arc 
  8.2114 +    /// \return The target of the arc 
  8.2115 +    Value operator[](const Key& e) const {
  8.2116 +      return digraph.target(e);
  8.2117 +    }
  8.2118 +
  8.2119 +  private:
  8.2120 +    const Digraph& digraph;
  8.2121 +  };
  8.2122 +
  8.2123 +  /// \brief Returns a \ref TargetMap class.
  8.2124 +  ///
  8.2125 +  /// This function just returns a \ref TargetMap class.
  8.2126 +  /// \relates TargetMap
  8.2127 +  template <typename Digraph>
  8.2128 +  inline TargetMap<Digraph> targetMap(const Digraph& digraph) {
  8.2129 +    return TargetMap<Digraph>(digraph);
  8.2130 +  }
  8.2131 +
  8.2132 +  /// \brief Returns the "forward" directed arc view of an edge.
  8.2133 +  ///
  8.2134 +  /// Returns the "forward" directed arc view of an edge.
  8.2135 +  /// \see BackwardMap
  8.2136 +  /// \author Balazs Dezso
  8.2137 +  template <typename Digraph>
  8.2138 +  class ForwardMap {
  8.2139 +  public:
  8.2140 +
  8.2141 +    typedef typename Digraph::Arc Value;
  8.2142 +    typedef typename Digraph::Edge Key;
  8.2143 +
  8.2144 +    /// \brief Constructor
  8.2145 +    ///
  8.2146 +    /// Constructor
  8.2147 +    /// \param _digraph The digraph that the map belongs to.
  8.2148 +    explicit ForwardMap(const Digraph& _digraph) : digraph(_digraph) {}
  8.2149 +
  8.2150 +    /// \brief The subscript operator.
  8.2151 +    ///
  8.2152 +    /// The subscript operator.
  8.2153 +    /// \param key An edge 
  8.2154 +    /// \return The "forward" directed arc view of edge 
  8.2155 +    Value operator[](const Key& key) const {
  8.2156 +      return digraph.direct(key, true);
  8.2157 +    }
  8.2158 +
  8.2159 +  private:
  8.2160 +    const Digraph& digraph;
  8.2161 +  };
  8.2162 +
  8.2163 +  /// \brief Returns a \ref ForwardMap class.
  8.2164 +  ///
  8.2165 +  /// This function just returns an \ref ForwardMap class.
  8.2166 +  /// \relates ForwardMap
  8.2167 +  template <typename Digraph>
  8.2168 +  inline ForwardMap<Digraph> forwardMap(const Digraph& digraph) {
  8.2169 +    return ForwardMap<Digraph>(digraph);
  8.2170 +  }
  8.2171 +
  8.2172 +  /// \brief Returns the "backward" directed arc view of an edge.
  8.2173 +  ///
  8.2174 +  /// Returns the "backward" directed arc view of an edge.
  8.2175 +  /// \see ForwardMap
  8.2176 +  /// \author Balazs Dezso
  8.2177 +  template <typename Digraph>
  8.2178 +  class BackwardMap {
  8.2179 +  public:
  8.2180 +
  8.2181 +    typedef typename Digraph::Arc Value;
  8.2182 +    typedef typename Digraph::Edge Key;
  8.2183 +
  8.2184 +    /// \brief Constructor
  8.2185 +    ///
  8.2186 +    /// Constructor
  8.2187 +    /// \param _digraph The digraph that the map belongs to.
  8.2188 +    explicit BackwardMap(const Digraph& _digraph) : digraph(_digraph) {}
  8.2189 +
  8.2190 +    /// \brief The subscript operator.
  8.2191 +    ///
  8.2192 +    /// The subscript operator.
  8.2193 +    /// \param key An edge 
  8.2194 +    /// \return The "backward" directed arc view of edge 
  8.2195 +    Value operator[](const Key& key) const {
  8.2196 +      return digraph.direct(key, false);
  8.2197 +    }
  8.2198 +
  8.2199 +  private:
  8.2200 +    const Digraph& digraph;
  8.2201 +  };
  8.2202 +
  8.2203 +  /// \brief Returns a \ref BackwardMap class
  8.2204 +
  8.2205 +  /// This function just returns a \ref BackwardMap class.
  8.2206 +  /// \relates BackwardMap
  8.2207 +  template <typename Digraph>
  8.2208 +  inline BackwardMap<Digraph> backwardMap(const Digraph& digraph) {
  8.2209 +    return BackwardMap<Digraph>(digraph);
  8.2210 +  }
  8.2211 +
  8.2212 +  /// \brief Potential difference map
  8.2213 +  ///
  8.2214 +  /// If there is an potential map on the nodes then we
  8.2215 +  /// can get an arc map as we get the substraction of the
  8.2216 +  /// values of the target and source.
  8.2217 +  template <typename Digraph, typename NodeMap>
  8.2218 +  class PotentialDifferenceMap {
  8.2219 +  public:
  8.2220 +    typedef typename Digraph::Arc Key;
  8.2221 +    typedef typename NodeMap::Value Value;
  8.2222 +
  8.2223 +    /// \brief Constructor
  8.2224 +    ///
  8.2225 +    /// Contructor of the map
  8.2226 +    explicit PotentialDifferenceMap(const Digraph& _digraph, 
  8.2227 +                                    const NodeMap& _potential) 
  8.2228 +      : digraph(_digraph), potential(_potential) {}
  8.2229 +
  8.2230 +    /// \brief Const subscription operator
  8.2231 +    ///
  8.2232 +    /// Const subscription operator
  8.2233 +    Value operator[](const Key& arc) const {
  8.2234 +      return potential[digraph.target(arc)] - potential[digraph.source(arc)];
  8.2235 +    }
  8.2236 +
  8.2237 +  private:
  8.2238 +    const Digraph& digraph;
  8.2239 +    const NodeMap& potential;
  8.2240 +  };
  8.2241 +
  8.2242 +  /// \brief Returns a PotentialDifferenceMap.
  8.2243 +  ///
  8.2244 +  /// This function just returns a PotentialDifferenceMap.
  8.2245 +  /// \relates PotentialDifferenceMap
  8.2246 +  template <typename Digraph, typename NodeMap>
  8.2247 +  PotentialDifferenceMap<Digraph, NodeMap> 
  8.2248 +  potentialDifferenceMap(const Digraph& digraph, const NodeMap& potential) {
  8.2249 +    return PotentialDifferenceMap<Digraph, NodeMap>(digraph, potential);
  8.2250 +  }
  8.2251 +
  8.2252 +  /// \brief Map of the node in-degrees.
  8.2253 +  ///
  8.2254 +  /// This map returns the in-degree of a node. Once it is constructed,
  8.2255 +  /// the degrees are stored in a standard NodeMap, so each query is done
  8.2256 +  /// in constant time. On the other hand, the values are updated automatically
  8.2257 +  /// whenever the digraph changes.
  8.2258 +  ///
  8.2259 +  /// \warning Besides addNode() and addArc(), a digraph structure may provide
  8.2260 +  /// alternative ways to modify the digraph. The correct behavior of InDegMap
  8.2261 +  /// is not guarantied if these additional features are used. For example
  8.2262 +  /// the functions \ref ListDigraph::changeSource() "changeSource()",
  8.2263 +  /// \ref ListDigraph::changeTarget() "changeTarget()" and
  8.2264 +  /// \ref ListDigraph::reverseArc() "reverseArc()"
  8.2265 +  /// of \ref ListDigraph will \e not update the degree values correctly.
  8.2266 +  ///
  8.2267 +  /// \sa OutDegMap
  8.2268 +
  8.2269 +  template <typename _Digraph>
  8.2270 +  class InDegMap  
  8.2271 +    : protected ItemSetTraits<_Digraph, typename _Digraph::Arc>
  8.2272 +      ::ItemNotifier::ObserverBase {
  8.2273 +
  8.2274 +  public:
  8.2275 +    
  8.2276 +    typedef _Digraph Digraph;
  8.2277 +    typedef int Value;
  8.2278 +    typedef typename Digraph::Node Key;
  8.2279 +
  8.2280 +    typedef typename ItemSetTraits<_Digraph, typename _Digraph::Arc>
  8.2281 +    ::ItemNotifier::ObserverBase Parent;
  8.2282 +
  8.2283 +  private:
  8.2284 +
  8.2285 +    class AutoNodeMap : public DefaultMap<_Digraph, Key, int> {
  8.2286 +    public:
  8.2287 +
  8.2288 +      typedef DefaultMap<_Digraph, Key, int> Parent;
  8.2289 +      typedef typename Parent::Digraph Digraph;
  8.2290 +
  8.2291 +      AutoNodeMap(const Digraph& digraph) : Parent(digraph, 0) {}
  8.2292 +      
  8.2293 +      virtual void add(const Key& key) {
  8.2294 +	Parent::add(key);
  8.2295 +	Parent::set(key, 0);
  8.2296 +      }
  8.2297 +
  8.2298 +      virtual void add(const std::vector<Key>& keys) {
  8.2299 +	Parent::add(keys);
  8.2300 +	for (int i = 0; i < int(keys.size()); ++i) {
  8.2301 +	  Parent::set(keys[i], 0);
  8.2302 +	}
  8.2303 +      }
  8.2304 +
  8.2305 +      virtual void build() {
  8.2306 +	Parent::build();
  8.2307 +	Key it;
  8.2308 +	typename Parent::Notifier* nf = Parent::notifier();
  8.2309 +	for (nf->first(it); it != INVALID; nf->next(it)) {
  8.2310 +	  Parent::set(it, 0);
  8.2311 +	}
  8.2312 +      }
  8.2313 +    };
  8.2314 +
  8.2315 +  public:
  8.2316 +
  8.2317 +    /// \brief Constructor.
  8.2318 +    ///
  8.2319 +    /// Constructor for creating in-degree map.
  8.2320 +    explicit InDegMap(const Digraph& _digraph) : digraph(_digraph), deg(_digraph) {
  8.2321 +      Parent::attach(digraph.notifier(typename _Digraph::Arc()));
  8.2322 +      
  8.2323 +      for(typename _Digraph::NodeIt it(digraph); it != INVALID; ++it) {
  8.2324 +	deg[it] = countInArcs(digraph, it);
  8.2325 +      }
  8.2326 +    }
  8.2327 +    
  8.2328 +    /// Gives back the in-degree of a Node.
  8.2329 +    int operator[](const Key& key) const {
  8.2330 +      return deg[key];
  8.2331 +    }
  8.2332 +
  8.2333 +  protected:
  8.2334 +    
  8.2335 +    typedef typename Digraph::Arc Arc;
  8.2336 +
  8.2337 +    virtual void add(const Arc& arc) {
  8.2338 +      ++deg[digraph.target(arc)];
  8.2339 +    }
  8.2340 +
  8.2341 +    virtual void add(const std::vector<Arc>& arcs) {
  8.2342 +      for (int i = 0; i < int(arcs.size()); ++i) {
  8.2343 +        ++deg[digraph.target(arcs[i])];
  8.2344 +      }
  8.2345 +    }
  8.2346 +
  8.2347 +    virtual void erase(const Arc& arc) {
  8.2348 +      --deg[digraph.target(arc)];
  8.2349 +    }
  8.2350 +
  8.2351 +    virtual void erase(const std::vector<Arc>& arcs) {
  8.2352 +      for (int i = 0; i < int(arcs.size()); ++i) {
  8.2353 +        --deg[digraph.target(arcs[i])];
  8.2354 +      }
  8.2355 +    }
  8.2356 +
  8.2357 +    virtual void build() {
  8.2358 +      for(typename _Digraph::NodeIt it(digraph); it != INVALID; ++it) {
  8.2359 +	deg[it] = countInArcs(digraph, it);
  8.2360 +      }      
  8.2361 +    }
  8.2362 +
  8.2363 +    virtual void clear() {
  8.2364 +      for(typename _Digraph::NodeIt it(digraph); it != INVALID; ++it) {
  8.2365 +	deg[it] = 0;
  8.2366 +      }
  8.2367 +    }
  8.2368 +  private:
  8.2369 +    
  8.2370 +    const _Digraph& digraph;
  8.2371 +    AutoNodeMap deg;
  8.2372 +  };
  8.2373 +
  8.2374 +  /// \brief Map of the node out-degrees.
  8.2375 +  ///
  8.2376 +  /// This map returns the out-degree of a node. Once it is constructed,
  8.2377 +  /// the degrees are stored in a standard NodeMap, so each query is done
  8.2378 +  /// in constant time. On the other hand, the values are updated automatically
  8.2379 +  /// whenever the digraph changes.
  8.2380 +  ///
  8.2381 +  /// \warning Besides addNode() and addArc(), a digraph structure may provide
  8.2382 +  /// alternative ways to modify the digraph. The correct behavior of OutDegMap
  8.2383 +  /// is not guarantied if these additional features are used. For example
  8.2384 +  /// the functions \ref ListDigraph::changeSource() "changeSource()",
  8.2385 +  /// \ref ListDigraph::changeTarget() "changeTarget()" and
  8.2386 +  /// \ref ListDigraph::reverseArc() "reverseArc()"
  8.2387 +  /// of \ref ListDigraph will \e not update the degree values correctly.
  8.2388 +  ///
  8.2389 +  /// \sa InDegMap
  8.2390 +
  8.2391 +  template <typename _Digraph>
  8.2392 +  class OutDegMap  
  8.2393 +    : protected ItemSetTraits<_Digraph, typename _Digraph::Arc>
  8.2394 +      ::ItemNotifier::ObserverBase {
  8.2395 +
  8.2396 +  public:
  8.2397 +
  8.2398 +    typedef typename ItemSetTraits<_Digraph, typename _Digraph::Arc>
  8.2399 +    ::ItemNotifier::ObserverBase Parent;
  8.2400 +    
  8.2401 +    typedef _Digraph Digraph;
  8.2402 +    typedef int Value;
  8.2403 +    typedef typename Digraph::Node Key;
  8.2404 +
  8.2405 +  private:
  8.2406 +
  8.2407 +    class AutoNodeMap : public DefaultMap<_Digraph, Key, int> {
  8.2408 +    public:
  8.2409 +
  8.2410 +      typedef DefaultMap<_Digraph, Key, int> Parent;
  8.2411 +      typedef typename Parent::Digraph Digraph;
  8.2412 +
  8.2413 +      AutoNodeMap(const Digraph& digraph) : Parent(digraph, 0) {}
  8.2414 +      
  8.2415 +      virtual void add(const Key& key) {
  8.2416 +	Parent::add(key);
  8.2417 +	Parent::set(key, 0);
  8.2418 +      }
  8.2419 +      virtual void add(const std::vector<Key>& keys) {
  8.2420 +	Parent::add(keys);
  8.2421 +	for (int i = 0; i < int(keys.size()); ++i) {
  8.2422 +	  Parent::set(keys[i], 0);
  8.2423 +	}
  8.2424 +      }
  8.2425 +      virtual void build() {
  8.2426 +	Parent::build();
  8.2427 +	Key it;
  8.2428 +	typename Parent::Notifier* nf = Parent::notifier();
  8.2429 +	for (nf->first(it); it != INVALID; nf->next(it)) {
  8.2430 +	  Parent::set(it, 0);
  8.2431 +	}
  8.2432 +      }
  8.2433 +    };
  8.2434 +
  8.2435 +  public:
  8.2436 +
  8.2437 +    /// \brief Constructor.
  8.2438 +    ///
  8.2439 +    /// Constructor for creating out-degree map.
  8.2440 +    explicit OutDegMap(const Digraph& _digraph) : digraph(_digraph), deg(_digraph) {
  8.2441 +      Parent::attach(digraph.notifier(typename _Digraph::Arc()));
  8.2442 +      
  8.2443 +      for(typename _Digraph::NodeIt it(digraph); it != INVALID; ++it) {
  8.2444 +	deg[it] = countOutArcs(digraph, it);
  8.2445 +      }
  8.2446 +    }
  8.2447 +
  8.2448 +    /// Gives back the out-degree of a Node.
  8.2449 +    int operator[](const Key& key) const {
  8.2450 +      return deg[key];
  8.2451 +    }
  8.2452 +
  8.2453 +  protected:
  8.2454 +    
  8.2455 +    typedef typename Digraph::Arc Arc;
  8.2456 +
  8.2457 +    virtual void add(const Arc& arc) {
  8.2458 +      ++deg[digraph.source(arc)];
  8.2459 +    }
  8.2460 +
  8.2461 +    virtual void add(const std::vector<Arc>& arcs) {
  8.2462 +      for (int i = 0; i < int(arcs.size()); ++i) {
  8.2463 +        ++deg[digraph.source(arcs[i])];
  8.2464 +      }
  8.2465 +    }
  8.2466 +
  8.2467 +    virtual void erase(const Arc& arc) {
  8.2468 +      --deg[digraph.source(arc)];
  8.2469 +    }
  8.2470 +
  8.2471 +    virtual void erase(const std::vector<Arc>& arcs) {
  8.2472 +      for (int i = 0; i < int(arcs.size()); ++i) {
  8.2473 +        --deg[digraph.source(arcs[i])];
  8.2474 +      }
  8.2475 +    }
  8.2476 +
  8.2477 +    virtual void build() {
  8.2478 +      for(typename _Digraph::NodeIt it(digraph); it != INVALID; ++it) {
  8.2479 +	deg[it] = countOutArcs(digraph, it);
  8.2480 +      }      
  8.2481 +    }
  8.2482 +
  8.2483 +    virtual void clear() {
  8.2484 +      for(typename _Digraph::NodeIt it(digraph); it != INVALID; ++it) {
  8.2485 +	deg[it] = 0;
  8.2486 +      }
  8.2487 +    }
  8.2488 +  private:
  8.2489 +    
  8.2490 +    const _Digraph& digraph;
  8.2491 +    AutoNodeMap deg;
  8.2492 +  };
  8.2493 +
  8.2494 +
  8.2495 +  ///Dynamic arc look up between given endpoints.
  8.2496 +  
  8.2497 +  ///\ingroup gutils
  8.2498 +  ///Using this class, you can find an arc in a digraph from a given
  8.2499 +  ///source to a given target in amortized time <em>O(log d)</em>,
  8.2500 +  ///where <em>d</em> is the out-degree of the source node.
  8.2501 +  ///
  8.2502 +  ///It is possible to find \e all parallel arcs between two nodes with
  8.2503 +  ///the \c findFirst() and \c findNext() members.
  8.2504 +  ///
  8.2505 +  ///See the \ref ArcLookUp and \ref AllArcLookUp classes if your
  8.2506 +  ///digraph do not changed so frequently.
  8.2507 +  ///
  8.2508 +  ///This class uses a self-adjusting binary search tree, Sleator's
  8.2509 +  ///and Tarjan's Splay tree for guarantee the logarithmic amortized
  8.2510 +  ///time bound for arc lookups. This class also guarantees the
  8.2511 +  ///optimal time bound in a constant factor for any distribution of
  8.2512 +  ///queries.
  8.2513 +  ///
  8.2514 +  ///\param G The type of the underlying digraph.  
  8.2515 +  ///
  8.2516 +  ///\sa ArcLookUp  
  8.2517 +  ///\sa AllArcLookUp  
  8.2518 +  template<class G>
  8.2519 +  class DynArcLookUp 
  8.2520 +    : protected ItemSetTraits<G, typename G::Arc>::ItemNotifier::ObserverBase
  8.2521 +  {
  8.2522 +  public:
  8.2523 +    typedef typename ItemSetTraits<G, typename G::Arc>
  8.2524 +    ::ItemNotifier::ObserverBase Parent;
  8.2525 +
  8.2526 +    GRAPH_TYPEDEFS(typename G);
  8.2527 +    typedef G Digraph;
  8.2528 +
  8.2529 +  protected:
  8.2530 +
  8.2531 +    class AutoNodeMap : public DefaultMap<G, Node, Arc> {
  8.2532 +    public:
  8.2533 +
  8.2534 +      typedef DefaultMap<G, Node, Arc> Parent;
  8.2535 +
  8.2536 +      AutoNodeMap(const G& digraph) : Parent(digraph, INVALID) {}
  8.2537 +      
  8.2538 +      virtual void add(const Node& node) {
  8.2539 +	Parent::add(node);
  8.2540 +	Parent::set(node, INVALID);
  8.2541 +      }
  8.2542 +
  8.2543 +      virtual void add(const std::vector<Node>& nodes) {
  8.2544 +	Parent::add(nodes);
  8.2545 +	for (int i = 0; i < int(nodes.size()); ++i) {
  8.2546 +	  Parent::set(nodes[i], INVALID);
  8.2547 +	}
  8.2548 +      }
  8.2549 +
  8.2550 +      virtual void build() {
  8.2551 +	Parent::build();
  8.2552 +	Node it;
  8.2553 +	typename Parent::Notifier* nf = Parent::notifier();
  8.2554 +	for (nf->first(it); it != INVALID; nf->next(it)) {
  8.2555 +	  Parent::set(it, INVALID);
  8.2556 +	}
  8.2557 +      }
  8.2558 +    };
  8.2559 +
  8.2560 +    const Digraph &_g;
  8.2561 +    AutoNodeMap _head;
  8.2562 +    typename Digraph::template ArcMap<Arc> _parent;
  8.2563 +    typename Digraph::template ArcMap<Arc> _left;
  8.2564 +    typename Digraph::template ArcMap<Arc> _right;
  8.2565 +    
  8.2566 +    class ArcLess {
  8.2567 +      const Digraph &g;
  8.2568 +    public:
  8.2569 +      ArcLess(const Digraph &_g) : g(_g) {}
  8.2570 +      bool operator()(Arc a,Arc b) const 
  8.2571 +      {
  8.2572 +	return g.target(a)<g.target(b);
  8.2573 +      }
  8.2574 +    };
  8.2575 +    
  8.2576 +  public:
  8.2577 +    
  8.2578 +    ///Constructor
  8.2579 +
  8.2580 +    ///Constructor.
  8.2581 +    ///
  8.2582 +    ///It builds up the search database.
  8.2583 +    DynArcLookUp(const Digraph &g) 
  8.2584 +      : _g(g),_head(g),_parent(g),_left(g),_right(g) 
  8.2585 +    { 
  8.2586 +      Parent::attach(_g.notifier(typename Digraph::Arc()));
  8.2587 +      refresh(); 
  8.2588 +    }
  8.2589 +    
  8.2590 +  protected:
  8.2591 +
  8.2592 +    virtual void add(const Arc& arc) {
  8.2593 +      insert(arc);
  8.2594 +    }
  8.2595 +
  8.2596 +    virtual void add(const std::vector<Arc>& arcs) {
  8.2597 +      for (int i = 0; i < int(arcs.size()); ++i) {
  8.2598 +	insert(arcs[i]);
  8.2599 +      }
  8.2600 +    }
  8.2601 +
  8.2602 +    virtual void erase(const Arc& arc) {
  8.2603 +      remove(arc);
  8.2604 +    }
  8.2605 +
  8.2606 +    virtual void erase(const std::vector<Arc>& arcs) {
  8.2607 +      for (int i = 0; i < int(arcs.size()); ++i) {
  8.2608 +	remove(arcs[i]);
  8.2609 +      }     
  8.2610 +    }
  8.2611 +
  8.2612 +    virtual void build() {
  8.2613 +      refresh();
  8.2614 +    }
  8.2615 +
  8.2616 +    virtual void clear() {
  8.2617 +      for(NodeIt n(_g);n!=INVALID;++n) {
  8.2618 +	_head.set(n, INVALID);
  8.2619 +      }
  8.2620 +    }
  8.2621 +
  8.2622 +    void insert(Arc arc) {
  8.2623 +      Node s = _g.source(arc);
  8.2624 +      Node t = _g.target(arc);
  8.2625 +      _left.set(arc, INVALID);
  8.2626 +      _right.set(arc, INVALID);
  8.2627 +      
  8.2628 +      Arc e = _head[s];
  8.2629 +      if (e == INVALID) {
  8.2630 +	_head.set(s, arc);
  8.2631 +	_parent.set(arc, INVALID);
  8.2632 +	return;
  8.2633 +      }
  8.2634 +      while (true) {
  8.2635 +	if (t < _g.target(e)) {
  8.2636 +	  if (_left[e] == INVALID) {
  8.2637 +	    _left.set(e, arc);
  8.2638 +	    _parent.set(arc, e);
  8.2639 +	    splay(arc);
  8.2640 +	    return;
  8.2641 +	  } else {
  8.2642 +	    e = _left[e];
  8.2643 +	  }
  8.2644 +	} else {
  8.2645 +	  if (_right[e] == INVALID) {
  8.2646 +	    _right.set(e, arc);
  8.2647 +	    _parent.set(arc, e);
  8.2648 +	    splay(arc);
  8.2649 +	    return;
  8.2650 +	  } else {
  8.2651 +	    e = _right[e];
  8.2652 +	  }
  8.2653 +	}
  8.2654 +      }
  8.2655 +    }
  8.2656 +
  8.2657 +    void remove(Arc arc) {
  8.2658 +      if (_left[arc] == INVALID) {
  8.2659 +	if (_right[arc] != INVALID) {
  8.2660 +	  _parent.set(_right[arc], _parent[arc]);
  8.2661 +	}
  8.2662 +	if (_parent[arc] != INVALID) {
  8.2663 +	  if (_left[_parent[arc]] == arc) {
  8.2664 +	    _left.set(_parent[arc], _right[arc]);
  8.2665 +	  } else {
  8.2666 +	    _right.set(_parent[arc], _right[arc]);
  8.2667 +	  }
  8.2668 +	} else {
  8.2669 +	  _head.set(_g.source(arc), _right[arc]);
  8.2670 +	}
  8.2671 +      } else if (_right[arc] == INVALID) {
  8.2672 +	_parent.set(_left[arc], _parent[arc]);
  8.2673 +	if (_parent[arc] != INVALID) {
  8.2674 +	  if (_left[_parent[arc]] == arc) {
  8.2675 +	    _left.set(_parent[arc], _left[arc]);
  8.2676 +	  } else {
  8.2677 +	    _right.set(_parent[arc], _left[arc]);
  8.2678 +	  }
  8.2679 +	} else {
  8.2680 +	  _head.set(_g.source(arc), _left[arc]);
  8.2681 +	}
  8.2682 +      } else {
  8.2683 +	Arc e = _left[arc];
  8.2684 +	if (_right[e] != INVALID) {
  8.2685 +	  e = _right[e];	  
  8.2686 +	  while (_right[e] != INVALID) {
  8.2687 +	    e = _right[e];
  8.2688 +	  }
  8.2689 +	  Arc s = _parent[e];
  8.2690 +	  _right.set(_parent[e], _left[e]);
  8.2691 +	  if (_left[e] != INVALID) {
  8.2692 +	    _parent.set(_left[e], _parent[e]);
  8.2693 +	  }
  8.2694 +	  
  8.2695 +	  _left.set(e, _left[arc]);
  8.2696 +	  _parent.set(_left[arc], e);
  8.2697 +	  _right.set(e, _right[arc]);
  8.2698 +	  _parent.set(_right[arc], e);
  8.2699 +
  8.2700 +	  _parent.set(e, _parent[arc]);
  8.2701 +	  if (_parent[arc] != INVALID) {
  8.2702 +	    if (_left[_parent[arc]] == arc) {
  8.2703 +	      _left.set(_parent[arc], e);
  8.2704 +	    } else {
  8.2705 +	      _right.set(_parent[arc], e);
  8.2706 +	    }
  8.2707 +	  }
  8.2708 +	  splay(s);
  8.2709 +	} else {
  8.2710 +	  _right.set(e, _right[arc]);
  8.2711 +	  _parent.set(_right[arc], e);
  8.2712 +
  8.2713 +	  if (_parent[arc] != INVALID) {
  8.2714 +	    if (_left[_parent[arc]] == arc) {
  8.2715 +	      _left.set(_parent[arc], e);
  8.2716 +	    } else {
  8.2717 +	      _right.set(_parent[arc], e);
  8.2718 +	    }
  8.2719 +	  } else {
  8.2720 +	    _head.set(_g.source(arc), e);
  8.2721 +	  }
  8.2722 +	}
  8.2723 +      }
  8.2724 +    }
  8.2725 +
  8.2726 +    Arc refreshRec(std::vector<Arc> &v,int a,int b) 
  8.2727 +    {
  8.2728 +      int m=(a+b)/2;
  8.2729 +      Arc me=v[m];
  8.2730 +      if (a < m) {
  8.2731 +	Arc left = refreshRec(v,a,m-1);
  8.2732 +	_left.set(me, left);
  8.2733 +	_parent.set(left, me);
  8.2734 +      } else {
  8.2735 +	_left.set(me, INVALID);
  8.2736 +      }
  8.2737 +      if (m < b) {
  8.2738 +	Arc right = refreshRec(v,m+1,b);
  8.2739 +	_right.set(me, right);
  8.2740 +	_parent.set(right, me);
  8.2741 +      } else {
  8.2742 +	_right.set(me, INVALID);
  8.2743 +      }
  8.2744 +      return me;
  8.2745 +    }
  8.2746 +
  8.2747 +    void refresh() {
  8.2748 +      for(NodeIt n(_g);n!=INVALID;++n) {
  8.2749 +	std::vector<Arc> v;
  8.2750 +	for(OutArcIt e(_g,n);e!=INVALID;++e) v.push_back(e);
  8.2751 +	if(v.size()) {
  8.2752 +	  std::sort(v.begin(),v.end(),ArcLess(_g));
  8.2753 +	  Arc head = refreshRec(v,0,v.size()-1);
  8.2754 +	  _head.set(n, head);
  8.2755 +	  _parent.set(head, INVALID);
  8.2756 +	}
  8.2757 +	else _head.set(n, INVALID);
  8.2758 +      }
  8.2759 +    }
  8.2760 +
  8.2761 +    void zig(Arc v) {        
  8.2762 +      Arc w = _parent[v];
  8.2763 +      _parent.set(v, _parent[w]);
  8.2764 +      _parent.set(w, v);
  8.2765 +      _left.set(w, _right[v]);
  8.2766 +      _right.set(v, w);
  8.2767 +      if (_parent[v] != INVALID) {
  8.2768 +	if (_right[_parent[v]] == w) {
  8.2769 +	  _right.set(_parent[v], v);
  8.2770 +	} else {
  8.2771 +	  _left.set(_parent[v], v);
  8.2772 +	}
  8.2773 +      }
  8.2774 +      if (_left[w] != INVALID){
  8.2775 +	_parent.set(_left[w], w);
  8.2776 +      }
  8.2777 +    }
  8.2778 +
  8.2779 +    void zag(Arc v) {        
  8.2780 +      Arc w = _parent[v];
  8.2781 +      _parent.set(v, _parent[w]);
  8.2782 +      _parent.set(w, v);
  8.2783 +      _right.set(w, _left[v]);
  8.2784 +      _left.set(v, w);
  8.2785 +      if (_parent[v] != INVALID){
  8.2786 +	if (_left[_parent[v]] == w) {
  8.2787 +	  _left.set(_parent[v], v);
  8.2788 +	} else {
  8.2789 +	  _right.set(_parent[v], v);
  8.2790 +	}
  8.2791 +      }
  8.2792 +      if (_right[w] != INVALID){
  8.2793 +	_parent.set(_right[w], w);
  8.2794 +      }
  8.2795 +    }
  8.2796 +
  8.2797 +    void splay(Arc v) {
  8.2798 +      while (_parent[v] != INVALID) {
  8.2799 +	if (v == _left[_parent[v]]) {
  8.2800 +	  if (_parent[_parent[v]] == INVALID) {
  8.2801 +	    zig(v);
  8.2802 +	  } else {
  8.2803 +	    if (_parent[v] == _left[_parent[_parent[v]]]) {
  8.2804 +	      zig(_parent[v]);
  8.2805 +	      zig(v);
  8.2806 +	    } else {
  8.2807 +	      zig(v);
  8.2808 +	      zag(v);
  8.2809 +	    }
  8.2810 +	  }
  8.2811 +	} else {
  8.2812 +	  if (_parent[_parent[v]] == INVALID) {
  8.2813 +	    zag(v);
  8.2814 +	  } else {
  8.2815 +	    if (_parent[v] == _left[_parent[_parent[v]]]) {
  8.2816 +	      zag(v);
  8.2817 +	      zig(v);
  8.2818 +	    } else {
  8.2819 +	      zag(_parent[v]);
  8.2820 +	      zag(v);
  8.2821 +	    }
  8.2822 +	  }
  8.2823 +	}
  8.2824 +      }
  8.2825 +      _head[_g.source(v)] = v;
  8.2826 +    }
  8.2827 +
  8.2828 +
  8.2829 +  public:
  8.2830 +    
  8.2831 +    ///Find an arc between two nodes.
  8.2832 +    
  8.2833 +    ///Find an arc between two nodes in time <em>O(</em>log<em>d)</em>, where
  8.2834 +    /// <em>d</em> is the number of outgoing arcs of \c s.
  8.2835 +    ///\param s The source node
  8.2836 +    ///\param t The target node
  8.2837 +    ///\return An arc from \c s to \c t if there exists,
  8.2838 +    ///\ref INVALID otherwise.
  8.2839 +    Arc operator()(Node s, Node t) const
  8.2840 +    {
  8.2841 +      Arc e = _head[s];
  8.2842 +      while (true) {
  8.2843 +	if (_g.target(e) == t) {
  8.2844 +	  const_cast<DynArcLookUp&>(*this).splay(e);
  8.2845 +	  return e;
  8.2846 +	} else if (t < _g.target(e)) {
  8.2847 +	  if (_left[e] == INVALID) {
  8.2848 +	    const_cast<DynArcLookUp&>(*this).splay(e);
  8.2849 +	    return INVALID;
  8.2850 +	  } else {
  8.2851 +	    e = _left[e];
  8.2852 +	  }
  8.2853 +	} else  {
  8.2854 +	  if (_right[e] == INVALID) {
  8.2855 +	    const_cast<DynArcLookUp&>(*this).splay(e);
  8.2856 +	    return INVALID;
  8.2857 +	  } else {
  8.2858 +	    e = _right[e];
  8.2859 +	  }
  8.2860 +	}
  8.2861 +      }
  8.2862 +    }
  8.2863 +
  8.2864 +    ///Find the first arc between two nodes.
  8.2865 +    
  8.2866 +    ///Find the first arc between two nodes in time
  8.2867 +    /// <em>O(</em>log<em>d)</em>, where <em>d</em> is the number of
  8.2868 +    /// outgoing arcs of \c s.  
  8.2869 +    ///\param s The source node 
  8.2870 +    ///\param t The target node
  8.2871 +    ///\return An arc from \c s to \c t if there exists, \ref INVALID
  8.2872 +    /// otherwise.
  8.2873 +    Arc findFirst(Node s, Node t) const
  8.2874 +    {
  8.2875 +      Arc e = _head[s];
  8.2876 +      Arc r = INVALID;
  8.2877 +      while (true) {
  8.2878 +	if (_g.target(e) < t) {
  8.2879 +	  if (_right[e] == INVALID) {
  8.2880 +	    const_cast<DynArcLookUp&>(*this).splay(e);
  8.2881 +	    return r;
  8.2882 +	  } else {
  8.2883 +	    e = _right[e];
  8.2884 +	  }
  8.2885 +	} else {
  8.2886 +	  if (_g.target(e) == t) {
  8.2887 +	    r = e;
  8.2888 +	  }
  8.2889 +	  if (_left[e] == INVALID) {
  8.2890 +	    const_cast<DynArcLookUp&>(*this).splay(e);
  8.2891 +	    return r;
  8.2892 +	  } else {
  8.2893 +	    e = _left[e];
  8.2894 +	  }
  8.2895 +	}
  8.2896 +      }
  8.2897 +    }
  8.2898 +
  8.2899 +    ///Find the next arc between two nodes.
  8.2900 +    
  8.2901 +    ///Find the next arc between two nodes in time
  8.2902 +    /// <em>O(</em>log<em>d)</em>, where <em>d</em> is the number of
  8.2903 +    /// outgoing arcs of \c s.  
  8.2904 +    ///\param s The source node 
  8.2905 +    ///\param t The target node
  8.2906 +    ///\return An arc from \c s to \c t if there exists, \ref INVALID
  8.2907 +    /// otherwise.
  8.2908 +
  8.2909 +    ///\note If \c e is not the result of the previous \c findFirst()
  8.2910 +    ///operation then the amorized time bound can not be guaranteed.
  8.2911 +#ifdef DOXYGEN
  8.2912 +    Arc findNext(Node s, Node t, Arc e) const
  8.2913 +#else
  8.2914 +    Arc findNext(Node, Node t, Arc e) const
  8.2915 +#endif
  8.2916 +    {
  8.2917 +      if (_right[e] != INVALID) {
  8.2918 +	e = _right[e];
  8.2919 +	while (_left[e] != INVALID) {
  8.2920 +	  e = _left[e];
  8.2921 +	}
  8.2922 +	const_cast<DynArcLookUp&>(*this).splay(e);
  8.2923 +      } else {
  8.2924 +	while (_parent[e] != INVALID && _right[_parent[e]] ==  e) {
  8.2925 +	  e = _parent[e];
  8.2926 +	}
  8.2927 +	if (_parent[e] == INVALID) {
  8.2928 +	  return INVALID;
  8.2929 +	} else {
  8.2930 +	  e = _parent[e];
  8.2931 +	  const_cast<DynArcLookUp&>(*this).splay(e);
  8.2932 +	}
  8.2933 +      }
  8.2934 +      if (_g.target(e) == t) return e;
  8.2935 +      else return INVALID;    
  8.2936 +    }
  8.2937 +
  8.2938 +  };
  8.2939 +
  8.2940 +  ///Fast arc look up between given endpoints.
  8.2941 +  
  8.2942 +  ///\ingroup gutils
  8.2943 +  ///Using this class, you can find an arc in a digraph from a given
  8.2944 +  ///source to a given target in time <em>O(log d)</em>,
  8.2945 +  ///where <em>d</em> is the out-degree of the source node.
  8.2946 +  ///
  8.2947 +  ///It is not possible to find \e all parallel arcs between two nodes.
  8.2948 +  ///Use \ref AllArcLookUp for this purpose.
  8.2949 +  ///
  8.2950 +  ///\warning This class is static, so you should refresh() (or at least
  8.2951 +  ///refresh(Node)) this data structure
  8.2952 +  ///whenever the digraph changes. This is a time consuming (superlinearly
  8.2953 +  ///proportional (<em>O(m</em>log<em>m)</em>) to the number of arcs).
  8.2954 +  ///
  8.2955 +  ///\param G The type of the underlying digraph.
  8.2956 +  ///
  8.2957 +  ///\sa DynArcLookUp
  8.2958 +  ///\sa AllArcLookUp  
  8.2959 +  template<class G>
  8.2960 +  class ArcLookUp 
  8.2961 +  {
  8.2962 +  public:
  8.2963 +    GRAPH_TYPEDEFS(typename G);
  8.2964 +    typedef G Digraph;
  8.2965 +
  8.2966 +  protected:
  8.2967 +    const Digraph &_g;
  8.2968 +    typename Digraph::template NodeMap<Arc> _head;
  8.2969 +    typename Digraph::template ArcMap<Arc> _left;
  8.2970 +    typename Digraph::template ArcMap<Arc> _right;
  8.2971 +    
  8.2972 +    class ArcLess {
  8.2973 +      const Digraph &g;
  8.2974 +    public:
  8.2975 +      ArcLess(const Digraph &_g) : g(_g) {}
  8.2976 +      bool operator()(Arc a,Arc b) const 
  8.2977 +      {
  8.2978 +	return g.target(a)<g.target(b);
  8.2979 +      }
  8.2980 +    };
  8.2981 +    
  8.2982 +  public:
  8.2983 +    
  8.2984 +    ///Constructor
  8.2985 +
  8.2986 +    ///Constructor.
  8.2987 +    ///
  8.2988 +    ///It builds up the search database, which remains valid until the digraph
  8.2989 +    ///changes.
  8.2990 +    ArcLookUp(const Digraph &g) :_g(g),_head(g),_left(g),_right(g) {refresh();}
  8.2991 +    
  8.2992 +  private:
  8.2993 +    Arc refreshRec(std::vector<Arc> &v,int a,int b) 
  8.2994 +    {
  8.2995 +      int m=(a+b)/2;
  8.2996 +      Arc me=v[m];
  8.2997 +      _left[me] = a<m?refreshRec(v,a,m-1):INVALID;
  8.2998 +      _right[me] = m<b?refreshRec(v,m+1,b):INVALID;
  8.2999 +      return me;
  8.3000 +    }
  8.3001 +  public:
  8.3002 +    ///Refresh the data structure at a node.
  8.3003 +
  8.3004 +    ///Build up the search database of node \c n.
  8.3005 +    ///
  8.3006 +    ///It runs in time <em>O(d</em>log<em>d)</em>, where <em>d</em> is
  8.3007 +    ///the number of the outgoing arcs of \c n.
  8.3008 +    void refresh(Node n) 
  8.3009 +    {
  8.3010 +      std::vector<Arc> v;
  8.3011 +      for(OutArcIt e(_g,n);e!=INVALID;++e) v.push_back(e);
  8.3012 +      if(v.size()) {
  8.3013 +	std::sort(v.begin(),v.end(),ArcLess(_g));
  8.3014 +	_head[n]=refreshRec(v,0,v.size()-1);
  8.3015 +      }
  8.3016 +      else _head[n]=INVALID;
  8.3017 +    }