COIN-OR::LEMON - Graph Library

source: lemon-1.0/lemon/dfs.h @ 138:a0f755a30cf1

Last change on this file since 138:a0f755a30cf1 was 100:4f754b4cf82b, checked in by Alpar Juttner <alpar@…>, 12 years ago

Bfs/Dfs/Dijkstra? and their deps ported from svn trung -r 3441.

File size: 45.7 KB
Line 
1/* -*- C++ -*-
2 *
3 * This file is a part of LEMON, a generic C++ optimization library
4 *
5 * Copyright (C) 2003-2008
6 * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
7 * (Egervary Research Group on Combinatorial Optimization, EGRES).
8 *
9 * Permission to use, modify and distribute this software is granted
10 * provided that this copyright notice appears in all copies. For
11 * precise terms see the accompanying LICENSE file.
12 *
13 * This software is provided "AS IS" with no warranty of any kind,
14 * express or implied, and with no claim as to its suitability for any
15 * purpose.
16 *
17 */
18
19#ifndef LEMON_DFS_H
20#define LEMON_DFS_H
21
22///\ingroup search
23///\file
24///\brief Dfs algorithm.
25
26#include <lemon/list_graph.h>
27#include <lemon/graph_utils.h>
28#include <lemon/bits/path_dump.h>
29#include <lemon/bits/invalid.h>
30#include <lemon/error.h>
31#include <lemon/maps.h>
32
33#include <lemon/concept_check.h>
34
35namespace lemon {
36
37 
38  ///Default traits class of Dfs class.
39
40  ///Default traits class of Dfs class.
41  ///\param GR Digraph type.
42  template<class GR>
43  struct DfsDefaultTraits
44  {
45    ///The digraph type the algorithm runs on.
46    typedef GR Digraph;
47    ///\brief The type of the map that stores the last
48    ///arcs of the %DFS paths.
49    ///
50    ///The type of the map that stores the last
51    ///arcs of the %DFS paths.
52    ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
53    ///
54    typedef typename Digraph::template NodeMap<typename GR::Arc> PredMap;
55    ///Instantiates a PredMap.
56 
57    ///This function instantiates a \ref PredMap.
58    ///\param G is the digraph, to which we would like to define the PredMap.
59    ///\todo The digraph alone may be insufficient to initialize
60    static PredMap *createPredMap(const GR &G)
61    {
62      return new PredMap(G);
63    }
64
65    ///The type of the map that indicates which nodes are processed.
66 
67    ///The type of the map that indicates which nodes are processed.
68    ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
69    ///\todo named parameter to set this type, function to read and write.
70    typedef NullMap<typename Digraph::Node,bool> ProcessedMap;
71    ///Instantiates a ProcessedMap.
72 
73    ///This function instantiates a \ref ProcessedMap.
74    ///\param g is the digraph, to which
75    ///we would like to define the \ref ProcessedMap
76#ifdef DOXYGEN
77    static ProcessedMap *createProcessedMap(const GR &g)
78#else
79    static ProcessedMap *createProcessedMap(const GR &)
80#endif
81    {
82      return new ProcessedMap();
83    }
84    ///The type of the map that indicates which nodes are reached.
85 
86    ///The type of the map that indicates which nodes are reached.
87    ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
88    ///\todo named parameter to set this type, function to read and write.
89    typedef typename Digraph::template NodeMap<bool> ReachedMap;
90    ///Instantiates a ReachedMap.
91 
92    ///This function instantiates a \ref ReachedMap.
93    ///\param G is the digraph, to which
94    ///we would like to define the \ref ReachedMap.
95    static ReachedMap *createReachedMap(const GR &G)
96    {
97      return new ReachedMap(G);
98    }
99    ///The type of the map that stores the dists of the nodes.
100 
101    ///The type of the map that stores the dists of the nodes.
102    ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
103    ///
104    typedef typename Digraph::template NodeMap<int> DistMap;
105    ///Instantiates a DistMap.
106 
107    ///This function instantiates a \ref DistMap.
108    ///\param G is the digraph, to which we would like to define the \ref DistMap
109    static DistMap *createDistMap(const GR &G)
110    {
111      return new DistMap(G);
112    }
113  };
114 
115  ///%DFS algorithm class.
116 
117  ///\ingroup search
118  ///This class provides an efficient implementation of the %DFS algorithm.
119  ///
120  ///\param GR The digraph type the algorithm runs on. The default value is
121  ///\ref ListDigraph. The value of GR is not used directly by Dfs, it
122  ///is only passed to \ref DfsDefaultTraits.
123  ///\param TR Traits class to set various data types used by the algorithm.
124  ///The default traits class is
125  ///\ref DfsDefaultTraits "DfsDefaultTraits<GR>".
126  ///See \ref DfsDefaultTraits for the documentation of
127  ///a Dfs traits class.
128  ///
129  ///\author Jacint Szabo and Alpar Juttner
130#ifdef DOXYGEN
131  template <typename GR,
132            typename TR>
133#else
134  template <typename GR=ListDigraph,
135            typename TR=DfsDefaultTraits<GR> >
136#endif
137  class Dfs {
138  public:
139    /**
140     * \brief \ref Exception for uninitialized parameters.
141     *
142     * This error represents problems in the initialization
143     * of the parameters of the algorithms.
144     */
145    class UninitializedParameter : public lemon::UninitializedParameter {
146    public:
147      virtual const char* what() const throw() {
148        return "lemon::Dfs::UninitializedParameter";
149      }
150    };
151
152    typedef TR Traits;
153    ///The type of the underlying digraph.
154    typedef typename TR::Digraph Digraph;
155    ///\e
156    typedef typename Digraph::Node Node;
157    ///\e
158    typedef typename Digraph::NodeIt NodeIt;
159    ///\e
160    typedef typename Digraph::Arc Arc;
161    ///\e
162    typedef typename Digraph::OutArcIt OutArcIt;
163   
164    ///\brief The type of the map that stores the last
165    ///arcs of the %DFS paths.
166    typedef typename TR::PredMap PredMap;
167    ///The type of the map indicating which nodes are reached.
168    typedef typename TR::ReachedMap ReachedMap;
169    ///The type of the map indicating which nodes are processed.
170    typedef typename TR::ProcessedMap ProcessedMap;
171    ///The type of the map that stores the dists of the nodes.
172    typedef typename TR::DistMap DistMap;
173  private:
174    /// Pointer to the underlying digraph.
175    const Digraph *G;
176    ///Pointer to the map of predecessors arcs.
177    PredMap *_pred;
178    ///Indicates if \ref _pred is locally allocated (\c true) or not.
179    bool local_pred;
180    ///Pointer to the map of distances.
181    DistMap *_dist;
182    ///Indicates if \ref _dist is locally allocated (\c true) or not.
183    bool local_dist;
184    ///Pointer to the map of reached status of the nodes.
185    ReachedMap *_reached;
186    ///Indicates if \ref _reached is locally allocated (\c true) or not.
187    bool local_reached;
188    ///Pointer to the map of processed status of the nodes.
189    ProcessedMap *_processed;
190    ///Indicates if \ref _processed is locally allocated (\c true) or not.
191    bool local_processed;
192
193    std::vector<typename Digraph::OutArcIt> _stack;
194    int _stack_head;
195
196    ///Creates the maps if necessary.
197   
198    ///\todo Better memory allocation (instead of new).
199    void create_maps()
200    {
201      if(!_pred) {
202        local_pred = true;
203        _pred = Traits::createPredMap(*G);
204      }
205      if(!_dist) {
206        local_dist = true;
207        _dist = Traits::createDistMap(*G);
208      }
209      if(!_reached) {
210        local_reached = true;
211        _reached = Traits::createReachedMap(*G);
212      }
213      if(!_processed) {
214        local_processed = true;
215        _processed = Traits::createProcessedMap(*G);
216      }
217    }
218
219  protected:
220
221    Dfs() {}
222   
223  public:
224
225    typedef Dfs Create;
226
227    ///\name Named template parameters
228
229    ///@{
230
231    template <class T>
232    struct DefPredMapTraits : public Traits {
233      typedef T PredMap;
234      static PredMap *createPredMap(const Digraph &G)
235      {
236        throw UninitializedParameter();
237      }
238    };
239    ///\brief \ref named-templ-param "Named parameter" for setting
240    ///PredMap type
241    ///
242    ///\ref named-templ-param "Named parameter" for setting PredMap type
243    ///
244    template <class T>
245    struct DefPredMap : public Dfs<Digraph, DefPredMapTraits<T> > {
246      typedef Dfs<Digraph, DefPredMapTraits<T> > Create;
247    };
248   
249   
250    template <class T>
251    struct DefDistMapTraits : public Traits {
252      typedef T DistMap;
253      static DistMap *createDistMap(const Digraph &)
254      {
255        throw UninitializedParameter();
256      }
257    };
258    ///\brief \ref named-templ-param "Named parameter" for setting
259    ///DistMap type
260    ///
261    ///\ref named-templ-param "Named parameter" for setting DistMap
262    ///type
263    template <class T>
264    struct DefDistMap {
265      typedef Dfs<Digraph, DefDistMapTraits<T> > Create;
266    };
267   
268    template <class T>
269    struct DefReachedMapTraits : public Traits {
270      typedef T ReachedMap;
271      static ReachedMap *createReachedMap(const Digraph &)
272      {
273        throw UninitializedParameter();
274      }
275    };
276    ///\brief \ref named-templ-param "Named parameter" for setting
277    ///ReachedMap type
278    ///
279    ///\ref named-templ-param "Named parameter" for setting ReachedMap type
280    ///
281    template <class T>
282    struct DefReachedMap : public Dfs< Digraph, DefReachedMapTraits<T> > {
283      typedef Dfs< Digraph, DefReachedMapTraits<T> > Create;
284    };
285
286    template <class T>
287    struct DefProcessedMapTraits : public Traits {
288      typedef T ProcessedMap;
289      static ProcessedMap *createProcessedMap(const Digraph &)
290      {
291        throw UninitializedParameter();
292      }
293    };
294    ///\brief \ref named-templ-param "Named parameter" for setting
295    ///ProcessedMap type
296    ///
297    ///\ref named-templ-param "Named parameter" for setting ProcessedMap type
298    ///
299    template <class T>
300    struct DefProcessedMap : public Dfs< Digraph, DefProcessedMapTraits<T> > {
301      typedef Dfs< Digraph, DefProcessedMapTraits<T> > Create;
302    };
303   
304    struct DefDigraphProcessedMapTraits : public Traits {
305      typedef typename Digraph::template NodeMap<bool> ProcessedMap;
306      static ProcessedMap *createProcessedMap(const Digraph &G)
307      {
308        return new ProcessedMap(G);
309      }
310    };
311    ///\brief \ref named-templ-param "Named parameter"
312    ///for setting the ProcessedMap type to be Digraph::NodeMap<bool>.
313    ///
314    ///\ref named-templ-param "Named parameter"
315    ///for setting the ProcessedMap type to be Digraph::NodeMap<bool>.
316    ///If you don't set it explicitely, it will be automatically allocated.
317    template <class T>
318    class DefProcessedMapToBeDefaultMap :
319      public Dfs< Digraph, DefDigraphProcessedMapTraits> {
320      typedef Dfs< Digraph, DefDigraphProcessedMapTraits> Create;
321    };
322   
323    ///@}
324
325  public:     
326   
327    ///Constructor.
328   
329    ///\param _G the digraph the algorithm will run on.
330    ///
331    Dfs(const Digraph& _G) :
332      G(&_G),
333      _pred(NULL), local_pred(false),
334      _dist(NULL), local_dist(false),
335      _reached(NULL), local_reached(false),
336      _processed(NULL), local_processed(false)
337    { }
338   
339    ///Destructor.
340    ~Dfs()
341    {
342      if(local_pred) delete _pred;
343      if(local_dist) delete _dist;
344      if(local_reached) delete _reached;
345      if(local_processed) delete _processed;
346    }
347
348    ///Sets the map storing the predecessor arcs.
349
350    ///Sets the map storing the predecessor arcs.
351    ///If you don't use this function before calling \ref run(),
352    ///it will allocate one. The destuctor deallocates this
353    ///automatically allocated map, of course.
354    ///\return <tt> (*this) </tt>
355    Dfs &predMap(PredMap &m)
356    {
357      if(local_pred) {
358        delete _pred;
359        local_pred=false;
360      }
361      _pred = &m;
362      return *this;
363    }
364
365    ///Sets the map storing the distances calculated by the algorithm.
366
367    ///Sets the map storing the distances calculated by the algorithm.
368    ///If you don't use this function before calling \ref run(),
369    ///it will allocate one. The destuctor deallocates this
370    ///automatically allocated map, of course.
371    ///\return <tt> (*this) </tt>
372    Dfs &distMap(DistMap &m)
373    {
374      if(local_dist) {
375        delete _dist;
376        local_dist=false;
377      }
378      _dist = &m;
379      return *this;
380    }
381
382    ///Sets the map indicating if a node is reached.
383
384    ///Sets the map indicating if a node is reached.
385    ///If you don't use this function before calling \ref run(),
386    ///it will allocate one. The destuctor deallocates this
387    ///automatically allocated map, of course.
388    ///\return <tt> (*this) </tt>
389    Dfs &reachedMap(ReachedMap &m)
390    {
391      if(local_reached) {
392        delete _reached;
393        local_reached=false;
394      }
395      _reached = &m;
396      return *this;
397    }
398
399    ///Sets the map indicating if a node is processed.
400
401    ///Sets the map indicating if a node is processed.
402    ///If you don't use this function before calling \ref run(),
403    ///it will allocate one. The destuctor deallocates this
404    ///automatically allocated map, of course.
405    ///\return <tt> (*this) </tt>
406    Dfs &processedMap(ProcessedMap &m)
407    {
408      if(local_processed) {
409        delete _processed;
410        local_processed=false;
411      }
412      _processed = &m;
413      return *this;
414    }
415
416  public:
417    ///\name Execution control
418    ///The simplest way to execute the algorithm is to use
419    ///one of the member functions called \c run(...).
420    ///\n
421    ///If you need more control on the execution,
422    ///first you must call \ref init(), then you can add a source node
423    ///with \ref addSource().
424    ///Finally \ref start() will perform the actual path
425    ///computation.
426
427    ///@{
428
429    ///Initializes the internal data structures.
430
431    ///Initializes the internal data structures.
432    ///
433    void init()
434    {
435      create_maps();
436      _stack.resize(countNodes(*G));
437      _stack_head=-1;
438      for ( NodeIt u(*G) ; u!=INVALID ; ++u ) {
439        _pred->set(u,INVALID);
440        // _predNode->set(u,INVALID);
441        _reached->set(u,false);
442        _processed->set(u,false);
443      }
444    }
445   
446    ///Adds a new source node.
447
448    ///Adds a new source node to the set of nodes to be processed.
449    ///
450    ///\warning dists are wrong (or at least strange)
451    ///in case of multiple sources.
452    void addSource(Node s)
453    {
454      if(!(*_reached)[s])
455        {
456          _reached->set(s,true);
457          _pred->set(s,INVALID);
458          OutArcIt e(*G,s);
459          if(e!=INVALID) {
460            _stack[++_stack_head]=e;
461            _dist->set(s,_stack_head);
462          }
463          else {
464            _processed->set(s,true);
465            _dist->set(s,0);
466          }
467        }
468    }
469   
470    ///Processes the next arc.
471
472    ///Processes the next arc.
473    ///
474    ///\return The processed arc.
475    ///
476    ///\pre The stack must not be empty!
477    Arc processNextArc()
478    {
479      Node m;
480      Arc e=_stack[_stack_head];
481      if(!(*_reached)[m=G->target(e)]) {
482        _pred->set(m,e);
483        _reached->set(m,true);
484        ++_stack_head;
485        _stack[_stack_head] = OutArcIt(*G, m);
486        _dist->set(m,_stack_head);
487      }
488      else {
489        m=G->source(e);
490        ++_stack[_stack_head];
491      }
492      while(_stack_head>=0 && _stack[_stack_head]==INVALID) {
493        _processed->set(m,true);
494        --_stack_head;
495        if(_stack_head>=0) {
496          m=G->source(_stack[_stack_head]);
497          ++_stack[_stack_head];
498        }
499      }
500      return e;
501    }
502    ///Next arc to be processed.
503
504    ///Next arc to be processed.
505    ///
506    ///\return The next arc to be processed or INVALID if the stack is
507    /// empty.
508    OutArcIt nextArc()
509    {
510      return _stack_head>=0?_stack[_stack_head]:INVALID;
511    }
512
513    ///\brief Returns \c false if there are nodes
514    ///to be processed in the queue
515    ///
516    ///Returns \c false if there are nodes
517    ///to be processed in the queue
518    bool emptyQueue() { return _stack_head<0; }
519    ///Returns the number of the nodes to be processed.
520   
521    ///Returns the number of the nodes to be processed in the queue.
522    int queueSize() { return _stack_head+1; }
523   
524    ///Executes the algorithm.
525
526    ///Executes the algorithm.
527    ///
528    ///\pre init() must be called and at least one node should be added
529    ///with addSource() before using this function.
530    ///
531    ///This method runs the %DFS algorithm from the root node(s)
532    ///in order to
533    ///compute the
534    ///%DFS path to each node. The algorithm computes
535    ///- The %DFS tree.
536    ///- The distance of each node from the root(s) in the %DFS tree.
537    ///
538    void start()
539    {
540      while ( !emptyQueue() ) processNextArc();
541    }
542   
543    ///Executes the algorithm until \c dest is reached.
544
545    ///Executes the algorithm until \c dest is reached.
546    ///
547    ///\pre init() must be called and at least one node should be added
548    ///with addSource() before using this function.
549    ///
550    ///This method runs the %DFS algorithm from the root node(s)
551    ///in order to
552    ///compute the
553    ///%DFS path to \c dest. The algorithm computes
554    ///- The %DFS path to \c  dest.
555    ///- The distance of \c dest from the root(s) in the %DFS tree.
556    ///
557    void start(Node dest)
558    {
559      while ( !emptyQueue() && G->target(_stack[_stack_head])!=dest )
560        processNextArc();
561    }
562   
563    ///Executes the algorithm until a condition is met.
564
565    ///Executes the algorithm until a condition is met.
566    ///
567    ///\pre init() must be called and at least one node should be added
568    ///with addSource() before using this function.
569    ///
570    ///\param em must be a bool (or convertible) arc map. The algorithm
571    ///will stop when it reaches an arc \c e with <tt>em[e]</tt> true.
572    ///
573    ///\return The reached arc \c e with <tt>em[e]</tt> true or
574    ///\c INVALID if no such arc was found.
575    ///
576    ///\warning Contrary to \ref Bfs and \ref Dijkstra, \c em is an arc map,
577    ///not a node map.
578    template<class EM>
579    Arc start(const EM &em)
580    {
581      while ( !emptyQueue() && !em[_stack[_stack_head]] )
582        processNextArc();
583      return emptyQueue() ? INVALID : _stack[_stack_head];
584    }
585
586    ///Runs %DFS algorithm to visit all nodes in the digraph.
587   
588    ///This method runs the %DFS algorithm in order to
589    ///compute the
590    ///%DFS path to each node. The algorithm computes
591    ///- The %DFS tree.
592    ///- The distance of each node from the root in the %DFS tree.
593    ///
594    ///\note d.run() is just a shortcut of the following code.
595    ///\code
596    ///  d.init();
597    ///  for (NodeIt it(digraph); it != INVALID; ++it) {
598    ///    if (!d.reached(it)) {
599    ///      d.addSource(it);
600    ///      d.start();
601    ///    }
602    ///  }
603    ///\endcode
604    void run() {
605      init();
606      for (NodeIt it(*G); it != INVALID; ++it) {
607        if (!reached(it)) {
608          addSource(it);
609          start();
610        }
611      }
612    }
613
614    ///Runs %DFS algorithm from node \c s.
615   
616    ///This method runs the %DFS algorithm from a root node \c s
617    ///in order to
618    ///compute the
619    ///%DFS path to each node. The algorithm computes
620    ///- The %DFS tree.
621    ///- The distance of each node from the root in the %DFS tree.
622    ///
623    ///\note d.run(s) is just a shortcut of the following code.
624    ///\code
625    ///  d.init();
626    ///  d.addSource(s);
627    ///  d.start();
628    ///\endcode
629    void run(Node s) {
630      init();
631      addSource(s);
632      start();
633    }
634   
635    ///Finds the %DFS path between \c s and \c t.
636   
637    ///Finds the %DFS path between \c s and \c t.
638    ///
639    ///\return The length of the %DFS s---t path if there exists one,
640    ///0 otherwise.
641    ///\note Apart from the return value, d.run(s,t) is
642    ///just a shortcut of the following code.
643    ///\code
644    ///  d.init();
645    ///  d.addSource(s);
646    ///  d.start(t);
647    ///\endcode
648    int run(Node s,Node t) {
649      init();
650      addSource(s);
651      start(t);
652      return reached(t)?_stack_head+1:0;
653    }
654   
655    ///@}
656
657    ///\name Query Functions
658    ///The result of the %DFS algorithm can be obtained using these
659    ///functions.\n
660    ///Before the use of these functions,
661    ///either run() or start() must be called.
662   
663    ///@{
664
665    typedef PredMapPath<Digraph, PredMap> Path;
666
667    ///Gives back the shortest path.
668   
669    ///Gives back the shortest path.
670    ///\pre The \c t should be reachable from the source.
671    Path path(Node t)
672    {
673      return Path(*G, *_pred, t);
674    }
675
676    ///The distance of a node from the root(s).
677
678    ///Returns the distance of a node from the root(s).
679    ///\pre \ref run() must be called before using this function.
680    ///\warning If node \c v is unreachable from the root(s) then the return
681    ///value of this funcion is undefined.
682    int dist(Node v) const { return (*_dist)[v]; }
683
684    ///Returns the 'previous arc' of the %DFS tree.
685
686    ///For a node \c v it returns the 'previous arc'
687    ///of the %DFS path,
688    ///i.e. it returns the last arc of a %DFS path from the root(s) to \c
689    ///v. It is \ref INVALID
690    ///if \c v is unreachable from the root(s) or \c v is a root. The
691    ///%DFS tree used here is equal to the %DFS tree used in
692    ///\ref predNode().
693    ///\pre Either \ref run() or \ref start() must be called before using
694    ///this function.
695    Arc predArc(Node v) const { return (*_pred)[v];}
696
697    ///Returns the 'previous node' of the %DFS tree.
698
699    ///For a node \c v it returns the 'previous node'
700    ///of the %DFS tree,
701    ///i.e. it returns the last but one node from a %DFS path from the
702    ///root(s) to \c v.
703    ///It is INVALID if \c v is unreachable from the root(s) or
704    ///if \c v itself a root.
705    ///The %DFS tree used here is equal to the %DFS
706    ///tree used in \ref predArc().
707    ///\pre Either \ref run() or \ref start() must be called before
708    ///using this function.
709    Node predNode(Node v) const { return (*_pred)[v]==INVALID ? INVALID:
710                                  G->source((*_pred)[v]); }
711   
712    ///Returns a reference to the NodeMap of distances.
713
714    ///Returns a reference to the NodeMap of distances.
715    ///\pre Either \ref run() or \ref init() must
716    ///be called before using this function.
717    const DistMap &distMap() const { return *_dist;}
718 
719    ///Returns a reference to the %DFS arc-tree map.
720
721    ///Returns a reference to the NodeMap of the arcs of the
722    ///%DFS tree.
723    ///\pre Either \ref run() or \ref init()
724    ///must be called before using this function.
725    const PredMap &predMap() const { return *_pred;}
726 
727    ///Checks if a node is reachable from the root.
728
729    ///Returns \c true if \c v is reachable from the root(s).
730    ///\warning The source nodes are inditated as unreachable.
731    ///\pre Either \ref run() or \ref start()
732    ///must be called before using this function.
733    ///
734    bool reached(Node v) { return (*_reached)[v]; }
735   
736    ///@}
737  };
738
739  ///Default traits class of Dfs function.
740
741  ///Default traits class of Dfs function.
742  ///\param GR Digraph type.
743  template<class GR>
744  struct DfsWizardDefaultTraits
745  {
746    ///The digraph type the algorithm runs on.
747    typedef GR Digraph;
748    ///\brief The type of the map that stores the last
749    ///arcs of the %DFS paths.
750    ///
751    ///The type of the map that stores the last
752    ///arcs of the %DFS paths.
753    ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
754    ///
755    typedef NullMap<typename Digraph::Node,typename GR::Arc> PredMap;
756    ///Instantiates a PredMap.
757 
758    ///This function instantiates a \ref PredMap.
759    ///\param g is the digraph, to which we would like to define the PredMap.
760    ///\todo The digraph alone may be insufficient to initialize
761#ifdef DOXYGEN
762    static PredMap *createPredMap(const GR &g)
763#else
764    static PredMap *createPredMap(const GR &)
765#endif
766    {
767      return new PredMap();
768    }
769
770    ///The type of the map that indicates which nodes are processed.
771 
772    ///The type of the map that indicates which nodes are processed.
773    ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
774    ///\todo named parameter to set this type, function to read and write.
775    typedef NullMap<typename Digraph::Node,bool> ProcessedMap;
776    ///Instantiates a ProcessedMap.
777 
778    ///This function instantiates a \ref ProcessedMap.
779    ///\param g is the digraph, to which
780    ///we would like to define the \ref ProcessedMap
781#ifdef DOXYGEN
782    static ProcessedMap *createProcessedMap(const GR &g)
783#else
784    static ProcessedMap *createProcessedMap(const GR &)
785#endif
786    {
787      return new ProcessedMap();
788    }
789    ///The type of the map that indicates which nodes are reached.
790 
791    ///The type of the map that indicates which nodes are reached.
792    ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
793    ///\todo named parameter to set this type, function to read and write.
794    typedef typename Digraph::template NodeMap<bool> ReachedMap;
795    ///Instantiates a ReachedMap.
796 
797    ///This function instantiates a \ref ReachedMap.
798    ///\param G is the digraph, to which
799    ///we would like to define the \ref ReachedMap.
800    static ReachedMap *createReachedMap(const GR &G)
801    {
802      return new ReachedMap(G);
803    }
804    ///The type of the map that stores the dists of the nodes.
805 
806    ///The type of the map that stores the dists of the nodes.
807    ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
808    ///
809    typedef NullMap<typename Digraph::Node,int> DistMap;
810    ///Instantiates a DistMap.
811 
812    ///This function instantiates a \ref DistMap.
813    ///\param g is the digraph, to which we would like to define the \ref DistMap
814#ifdef DOXYGEN
815    static DistMap *createDistMap(const GR &g)
816#else
817    static DistMap *createDistMap(const GR &)
818#endif
819    {
820      return new DistMap();
821    }
822  };
823 
824  /// Default traits used by \ref DfsWizard
825
826  /// To make it easier to use Dfs algorithm
827  ///we have created a wizard class.
828  /// This \ref DfsWizard class needs default traits,
829  ///as well as the \ref Dfs class.
830  /// The \ref DfsWizardBase is a class to be the default traits of the
831  /// \ref DfsWizard class.
832  template<class GR>
833  class DfsWizardBase : public DfsWizardDefaultTraits<GR>
834  {
835
836    typedef DfsWizardDefaultTraits<GR> Base;
837  protected:
838    /// Type of the nodes in the digraph.
839    typedef typename Base::Digraph::Node Node;
840
841    /// Pointer to the underlying digraph.
842    void *_g;
843    ///Pointer to the map of reached nodes.
844    void *_reached;
845    ///Pointer to the map of processed nodes.
846    void *_processed;
847    ///Pointer to the map of predecessors arcs.
848    void *_pred;
849    ///Pointer to the map of distances.
850    void *_dist;
851    ///Pointer to the source node.
852    Node _source;
853   
854    public:
855    /// Constructor.
856   
857    /// This constructor does not require parameters, therefore it initiates
858    /// all of the attributes to default values (0, INVALID).
859    DfsWizardBase() : _g(0), _reached(0), _processed(0), _pred(0),
860                           _dist(0), _source(INVALID) {}
861
862    /// Constructor.
863   
864    /// This constructor requires some parameters,
865    /// listed in the parameters list.
866    /// Others are initiated to 0.
867    /// \param g is the initial value of  \ref _g
868    /// \param s is the initial value of  \ref _source
869    DfsWizardBase(const GR &g, Node s=INVALID) :
870      _g(reinterpret_cast<void*>(const_cast<GR*>(&g))),
871      _reached(0), _processed(0), _pred(0), _dist(0), _source(s) {}
872
873  };
874 
875  /// A class to make the usage of the Dfs algorithm easier
876
877  /// This class is created to make it easier to use the Dfs algorithm.
878  /// It uses the functions and features of the plain \ref Dfs,
879  /// but it is much simpler to use it.
880  ///
881  /// Simplicity means that the way to change the types defined
882  /// in the traits class is based on functions that returns the new class
883  /// and not on templatable built-in classes.
884  /// When using the plain \ref Dfs
885  /// the new class with the modified type comes from
886  /// the original class by using the ::
887  /// operator. In the case of \ref DfsWizard only
888  /// a function have to be called and it will
889  /// return the needed class.
890  ///
891  /// It does not have own \ref run method. When its \ref run method is called
892  /// it initiates a plain \ref Dfs object, and calls the \ref Dfs::run
893  /// method of it.
894  template<class TR>
895  class DfsWizard : public TR
896  {
897    typedef TR Base;
898
899    ///The type of the underlying digraph.
900    typedef typename TR::Digraph Digraph;
901    //\e
902    typedef typename Digraph::Node Node;
903    //\e
904    typedef typename Digraph::NodeIt NodeIt;
905    //\e
906    typedef typename Digraph::Arc Arc;
907    //\e
908    typedef typename Digraph::OutArcIt OutArcIt;
909   
910    ///\brief The type of the map that stores
911    ///the reached nodes
912    typedef typename TR::ReachedMap ReachedMap;
913    ///\brief The type of the map that stores
914    ///the processed nodes
915    typedef typename TR::ProcessedMap ProcessedMap;
916    ///\brief The type of the map that stores the last
917    ///arcs of the %DFS paths.
918    typedef typename TR::PredMap PredMap;
919    ///The type of the map that stores the distances of the nodes.
920    typedef typename TR::DistMap DistMap;
921
922  public:
923    /// Constructor.
924    DfsWizard() : TR() {}
925
926    /// Constructor that requires parameters.
927
928    /// Constructor that requires parameters.
929    /// These parameters will be the default values for the traits class.
930    DfsWizard(const Digraph &g, Node s=INVALID) :
931      TR(g,s) {}
932
933    ///Copy constructor
934    DfsWizard(const TR &b) : TR(b) {}
935
936    ~DfsWizard() {}
937
938    ///Runs Dfs algorithm from a given node.
939   
940    ///Runs Dfs algorithm from a given node.
941    ///The node can be given by the \ref source function.
942    void run()
943    {
944      if(Base::_source==INVALID) throw UninitializedParameter();
945      Dfs<Digraph,TR> alg(*reinterpret_cast<const Digraph*>(Base::_g));
946      if(Base::_reached)
947        alg.reachedMap(*reinterpret_cast<ReachedMap*>(Base::_reached));
948      if(Base::_processed)
949        alg.processedMap(*reinterpret_cast<ProcessedMap*>(Base::_processed));
950      if(Base::_pred)
951        alg.predMap(*reinterpret_cast<PredMap*>(Base::_pred));
952      if(Base::_dist)
953        alg.distMap(*reinterpret_cast<DistMap*>(Base::_dist));
954      alg.run(Base::_source);
955    }
956
957    ///Runs Dfs algorithm from the given node.
958
959    ///Runs Dfs algorithm from the given node.
960    ///\param s is the given source.
961    void run(Node s)
962    {
963      Base::_source=s;
964      run();
965    }
966
967    template<class T>
968    struct DefPredMapBase : public Base {
969      typedef T PredMap;
970      static PredMap *createPredMap(const Digraph &) { return 0; };
971      DefPredMapBase(const TR &b) : TR(b) {}
972    };
973   
974    ///\brief \ref named-templ-param "Named parameter"
975    ///function for setting PredMap type
976    ///
977    /// \ref named-templ-param "Named parameter"
978    ///function for setting PredMap type
979    ///
980    template<class T>
981    DfsWizard<DefPredMapBase<T> > predMap(const T &t)
982    {
983      Base::_pred=reinterpret_cast<void*>(const_cast<T*>(&t));
984      return DfsWizard<DefPredMapBase<T> >(*this);
985    }
986   
987 
988    template<class T>
989    struct DefReachedMapBase : public Base {
990      typedef T ReachedMap;
991      static ReachedMap *createReachedMap(const Digraph &) { return 0; };
992      DefReachedMapBase(const TR &b) : TR(b) {}
993    };
994   
995    ///\brief \ref named-templ-param "Named parameter"
996    ///function for setting ReachedMap
997    ///
998    /// \ref named-templ-param "Named parameter"
999    ///function for setting ReachedMap
1000    ///
1001    template<class T>
1002    DfsWizard<DefReachedMapBase<T> > reachedMap(const T &t)
1003    {
1004      Base::_pred=reinterpret_cast<void*>(const_cast<T*>(&t));
1005      return DfsWizard<DefReachedMapBase<T> >(*this);
1006    }
1007   
1008
1009    template<class T>
1010    struct DefProcessedMapBase : public Base {
1011      typedef T ProcessedMap;
1012      static ProcessedMap *createProcessedMap(const Digraph &) { return 0; };
1013      DefProcessedMapBase(const TR &b) : TR(b) {}
1014    };
1015   
1016    ///\brief \ref named-templ-param "Named parameter"
1017    ///function for setting ProcessedMap
1018    ///
1019    /// \ref named-templ-param "Named parameter"
1020    ///function for setting ProcessedMap
1021    ///
1022    template<class T>
1023    DfsWizard<DefProcessedMapBase<T> > processedMap(const T &t)
1024    {
1025      Base::_pred=reinterpret_cast<void*>(const_cast<T*>(&t));
1026      return DfsWizard<DefProcessedMapBase<T> >(*this);
1027    }
1028   
1029    template<class T>
1030    struct DefDistMapBase : public Base {
1031      typedef T DistMap;
1032      static DistMap *createDistMap(const Digraph &) { return 0; };
1033      DefDistMapBase(const TR &b) : TR(b) {}
1034    };
1035   
1036    ///\brief \ref named-templ-param "Named parameter"
1037    ///function for setting DistMap type
1038    ///
1039    /// \ref named-templ-param "Named parameter"
1040    ///function for setting DistMap type
1041    ///
1042    template<class T>
1043    DfsWizard<DefDistMapBase<T> > distMap(const T &t)
1044    {
1045      Base::_dist=reinterpret_cast<void*>(const_cast<T*>(&t));
1046      return DfsWizard<DefDistMapBase<T> >(*this);
1047    }
1048   
1049    /// Sets the source node, from which the Dfs algorithm runs.
1050
1051    /// Sets the source node, from which the Dfs algorithm runs.
1052    /// \param s is the source node.
1053    DfsWizard<TR> &source(Node s)
1054    {
1055      Base::_source=s;
1056      return *this;
1057    }
1058   
1059  };
1060 
1061  ///Function type interface for Dfs algorithm.
1062
1063  ///\ingroup search
1064  ///Function type interface for Dfs algorithm.
1065  ///
1066  ///This function also has several
1067  ///\ref named-templ-func-param "named parameters",
1068  ///they are declared as the members of class \ref DfsWizard.
1069  ///The following
1070  ///example shows how to use these parameters.
1071  ///\code
1072  ///  dfs(g,source).predMap(preds).run();
1073  ///\endcode
1074  ///\warning Don't forget to put the \ref DfsWizard::run() "run()"
1075  ///to the end of the parameter list.
1076  ///\sa DfsWizard
1077  ///\sa Dfs
1078  template<class GR>
1079  DfsWizard<DfsWizardBase<GR> >
1080  dfs(const GR &g,typename GR::Node s=INVALID)
1081  {
1082    return DfsWizard<DfsWizardBase<GR> >(g,s);
1083  }
1084
1085#ifdef DOXYGEN
1086  /// \brief Visitor class for dfs.
1087  /// 
1088  /// It gives a simple interface for a functional interface for dfs
1089  /// traversal. The traversal on a linear data structure.
1090  template <typename _Digraph>
1091  struct DfsVisitor {
1092    typedef _Digraph Digraph;
1093    typedef typename Digraph::Arc Arc;
1094    typedef typename Digraph::Node Node;
1095    /// \brief Called when the arc reach a node.
1096    ///
1097    /// It is called when the dfs find an arc which target is not
1098    /// reached yet.
1099    void discover(const Arc& arc) {}
1100    /// \brief Called when the node reached first time.
1101    ///
1102    /// It is Called when the node reached first time.
1103    void reach(const Node& node) {}
1104    /// \brief Called when we step back on an arc.
1105    ///
1106    /// It is called when the dfs should step back on the arc.
1107    void backtrack(const Arc& arc) {}
1108    /// \brief Called when we step back from the node.
1109    ///
1110    /// It is called when we step back from the node.
1111    void leave(const Node& node) {}
1112    /// \brief Called when the arc examined but target of the arc
1113    /// already discovered.
1114    ///
1115    /// It called when the arc examined but the target of the arc
1116    /// already discovered.
1117    void examine(const Arc& arc) {}
1118    /// \brief Called for the source node of the dfs.
1119    ///
1120    /// It is called for the source node of the dfs.
1121    void start(const Node& node) {}
1122    /// \brief Called when we leave the source node of the dfs.
1123    ///
1124    /// It is called when we leave the source node of the dfs.
1125    void stop(const Node& node) {}
1126
1127  };
1128#else
1129  template <typename _Digraph>
1130  struct DfsVisitor {
1131    typedef _Digraph Digraph;
1132    typedef typename Digraph::Arc Arc;
1133    typedef typename Digraph::Node Node;
1134    void discover(const Arc&) {}
1135    void reach(const Node&) {}
1136    void backtrack(const Arc&) {}
1137    void leave(const Node&) {}
1138    void examine(const Arc&) {}
1139    void start(const Node&) {}
1140    void stop(const Node&) {}
1141
1142    template <typename _Visitor>
1143    struct Constraints {
1144      void constraints() {
1145        Arc arc;
1146        Node node;
1147        visitor.discover(arc);
1148        visitor.reach(node);
1149        visitor.backtrack(arc);
1150        visitor.leave(node);
1151        visitor.examine(arc);
1152        visitor.start(node);
1153        visitor.stop(arc);
1154      }
1155      _Visitor& visitor;
1156    };
1157  };
1158#endif
1159
1160  /// \brief Default traits class of DfsVisit class.
1161  ///
1162  /// Default traits class of DfsVisit class.
1163  /// \param _Digraph Digraph type.
1164  template<class _Digraph>
1165  struct DfsVisitDefaultTraits {
1166
1167    /// \brief The digraph type the algorithm runs on.
1168    typedef _Digraph Digraph;
1169
1170    /// \brief The type of the map that indicates which nodes are reached.
1171    ///
1172    /// The type of the map that indicates which nodes are reached.
1173    /// It must meet the \ref concepts::WriteMap "WriteMap" concept.
1174    /// \todo named parameter to set this type, function to read and write.
1175    typedef typename Digraph::template NodeMap<bool> ReachedMap;
1176
1177    /// \brief Instantiates a ReachedMap.
1178    ///
1179    /// This function instantiates a \ref ReachedMap.
1180    /// \param digraph is the digraph, to which
1181    /// we would like to define the \ref ReachedMap.
1182    static ReachedMap *createReachedMap(const Digraph &digraph) {
1183      return new ReachedMap(digraph);
1184    }
1185
1186  };
1187 
1188  /// %DFS Visit algorithm class.
1189 
1190  /// \ingroup search
1191  /// This class provides an efficient implementation of the %DFS algorithm
1192  /// with visitor interface.
1193  ///
1194  /// The %DfsVisit class provides an alternative interface to the Dfs
1195  /// class. It works with callback mechanism, the DfsVisit object calls
1196  /// on every dfs event the \c Visitor class member functions.
1197  ///
1198  /// \param _Digraph The digraph type the algorithm runs on. The default value is
1199  /// \ref ListDigraph. The value of _Digraph is not used directly by Dfs, it
1200  /// is only passed to \ref DfsDefaultTraits.
1201  /// \param _Visitor The Visitor object for the algorithm. The
1202  /// \ref DfsVisitor "DfsVisitor<_Digraph>" is an empty Visitor which
1203  /// does not observe the Dfs events. If you want to observe the dfs
1204  /// events you should implement your own Visitor class.
1205  /// \param _Traits Traits class to set various data types used by the
1206  /// algorithm. The default traits class is
1207  /// \ref DfsVisitDefaultTraits "DfsVisitDefaultTraits<_Digraph>".
1208  /// See \ref DfsVisitDefaultTraits for the documentation of
1209  /// a Dfs visit traits class.
1210  ///
1211  /// \author Jacint Szabo, Alpar Juttner and Balazs Dezso
1212#ifdef DOXYGEN
1213  template <typename _Digraph, typename _Visitor, typename _Traits>
1214#else
1215  template <typename _Digraph = ListDigraph,
1216            typename _Visitor = DfsVisitor<_Digraph>,
1217            typename _Traits = DfsDefaultTraits<_Digraph> >
1218#endif
1219  class DfsVisit {
1220  public:
1221   
1222    /// \brief \ref Exception for uninitialized parameters.
1223    ///
1224    /// This error represents problems in the initialization
1225    /// of the parameters of the algorithms.
1226    class UninitializedParameter : public lemon::UninitializedParameter {
1227    public:
1228      virtual const char* what() const throw()
1229      {
1230        return "lemon::DfsVisit::UninitializedParameter";
1231      }
1232    };
1233
1234    typedef _Traits Traits;
1235
1236    typedef typename Traits::Digraph Digraph;
1237
1238    typedef _Visitor Visitor;
1239
1240    ///The type of the map indicating which nodes are reached.
1241    typedef typename Traits::ReachedMap ReachedMap;
1242
1243  private:
1244
1245    typedef typename Digraph::Node Node;
1246    typedef typename Digraph::NodeIt NodeIt;
1247    typedef typename Digraph::Arc Arc;
1248    typedef typename Digraph::OutArcIt OutArcIt;
1249
1250    /// Pointer to the underlying digraph.
1251    const Digraph *_digraph;
1252    /// Pointer to the visitor object.
1253    Visitor *_visitor;
1254    ///Pointer to the map of reached status of the nodes.
1255    ReachedMap *_reached;
1256    ///Indicates if \ref _reached is locally allocated (\c true) or not.
1257    bool local_reached;
1258
1259    std::vector<typename Digraph::Arc> _stack;
1260    int _stack_head;
1261
1262    /// \brief Creates the maps if necessary.
1263    ///
1264    /// Creates the maps if necessary.
1265    void create_maps() {
1266      if(!_reached) {
1267        local_reached = true;
1268        _reached = Traits::createReachedMap(*_digraph);
1269      }
1270    }
1271
1272  protected:
1273
1274    DfsVisit() {}
1275   
1276  public:
1277
1278    typedef DfsVisit Create;
1279
1280    /// \name Named template parameters
1281
1282    ///@{
1283    template <class T>
1284    struct DefReachedMapTraits : public Traits {
1285      typedef T ReachedMap;
1286      static ReachedMap *createReachedMap(const Digraph &digraph) {
1287        throw UninitializedParameter();
1288      }
1289    };
1290    /// \brief \ref named-templ-param "Named parameter" for setting
1291    /// ReachedMap type
1292    ///
1293    /// \ref named-templ-param "Named parameter" for setting ReachedMap type
1294    template <class T>
1295    struct DefReachedMap : public DfsVisit< Digraph, Visitor,
1296                                            DefReachedMapTraits<T> > {
1297      typedef DfsVisit< Digraph, Visitor, DefReachedMapTraits<T> > Create;
1298    };
1299    ///@}
1300
1301  public:     
1302   
1303    /// \brief Constructor.
1304    ///
1305    /// Constructor.
1306    ///
1307    /// \param digraph the digraph the algorithm will run on.
1308    /// \param visitor The visitor of the algorithm.
1309    ///
1310    DfsVisit(const Digraph& digraph, Visitor& visitor)
1311      : _digraph(&digraph), _visitor(&visitor),
1312        _reached(0), local_reached(false) {}
1313   
1314    /// \brief Destructor.
1315    ///
1316    /// Destructor.
1317    ~DfsVisit() {
1318      if(local_reached) delete _reached;
1319    }
1320
1321    /// \brief Sets the map indicating if a node is reached.
1322    ///
1323    /// Sets the map indicating if a node is reached.
1324    /// If you don't use this function before calling \ref run(),
1325    /// it will allocate one. The destuctor deallocates this
1326    /// automatically allocated map, of course.
1327    /// \return <tt> (*this) </tt>
1328    DfsVisit &reachedMap(ReachedMap &m) {
1329      if(local_reached) {
1330        delete _reached;
1331        local_reached=false;
1332      }
1333      _reached = &m;
1334      return *this;
1335    }
1336
1337  public:
1338    /// \name Execution control
1339    /// The simplest way to execute the algorithm is to use
1340    /// one of the member functions called \c run(...).
1341    /// \n
1342    /// If you need more control on the execution,
1343    /// first you must call \ref init(), then you can adda source node
1344    /// with \ref addSource().
1345    /// Finally \ref start() will perform the actual path
1346    /// computation.
1347
1348    /// @{
1349    /// \brief Initializes the internal data structures.
1350    ///
1351    /// Initializes the internal data structures.
1352    ///
1353    void init() {
1354      create_maps();
1355      _stack.resize(countNodes(*_digraph));
1356      _stack_head = -1;
1357      for (NodeIt u(*_digraph) ; u != INVALID ; ++u) {
1358        _reached->set(u, false);
1359      }
1360    }
1361   
1362    /// \brief Adds a new source node.
1363    ///
1364    /// Adds a new source node to the set of nodes to be processed.
1365    void addSource(Node s) {
1366      if(!(*_reached)[s]) {
1367          _reached->set(s,true);
1368          _visitor->start(s);
1369          _visitor->reach(s);
1370          Arc e;
1371          _digraph->firstOut(e, s);
1372          if (e != INVALID) {
1373            _stack[++_stack_head] = e;
1374          } else {
1375            _visitor->leave(s);
1376          }
1377        }
1378    }
1379   
1380    /// \brief Processes the next arc.
1381    ///
1382    /// Processes the next arc.
1383    ///
1384    /// \return The processed arc.
1385    ///
1386    /// \pre The stack must not be empty!
1387    Arc processNextArc() {
1388      Arc e = _stack[_stack_head];
1389      Node m = _digraph->target(e);
1390      if(!(*_reached)[m]) {
1391        _visitor->discover(e);
1392        _visitor->reach(m);
1393        _reached->set(m, true);
1394        _digraph->firstOut(_stack[++_stack_head], m);
1395      } else {
1396        _visitor->examine(e);
1397        m = _digraph->source(e);
1398        _digraph->nextOut(_stack[_stack_head]);
1399      }
1400      while (_stack_head>=0 && _stack[_stack_head] == INVALID) {
1401        _visitor->leave(m);
1402        --_stack_head;
1403        if (_stack_head >= 0) {
1404          _visitor->backtrack(_stack[_stack_head]);
1405          m = _digraph->source(_stack[_stack_head]);
1406          _digraph->nextOut(_stack[_stack_head]);
1407        } else {
1408          _visitor->stop(m);     
1409        }
1410      }
1411      return e;
1412    }
1413
1414    /// \brief Next arc to be processed.
1415    ///
1416    /// Next arc to be processed.
1417    ///
1418    /// \return The next arc to be processed or INVALID if the stack is
1419    /// empty.
1420    Arc nextArc() {
1421      return _stack_head >= 0 ? _stack[_stack_head] : INVALID;
1422    }
1423
1424    /// \brief Returns \c false if there are nodes
1425    /// to be processed in the queue
1426    ///
1427    /// Returns \c false if there are nodes
1428    /// to be processed in the queue
1429    bool emptyQueue() { return _stack_head < 0; }
1430
1431    /// \brief Returns the number of the nodes to be processed.
1432    ///
1433    /// Returns the number of the nodes to be processed in the queue.
1434    int queueSize() { return _stack_head + 1; }
1435   
1436    /// \brief Executes the algorithm.
1437    ///
1438    /// Executes the algorithm.
1439    ///
1440    /// \pre init() must be called and at least one node should be added
1441    /// with addSource() before using this function.
1442    void start() {
1443      while ( !emptyQueue() ) processNextArc();
1444    }
1445   
1446    /// \brief Executes the algorithm until \c dest is reached.
1447    ///
1448    /// Executes the algorithm until \c dest is reached.
1449    ///
1450    /// \pre init() must be called and at least one node should be added
1451    /// with addSource() before using this function.
1452    void start(Node dest) {
1453      while ( !emptyQueue() && _digraph->target(_stack[_stack_head]) != dest )
1454        processNextArc();
1455    }
1456   
1457    /// \brief Executes the algorithm until a condition is met.
1458    ///
1459    /// Executes the algorithm until a condition is met.
1460    ///
1461    /// \pre init() must be called and at least one node should be added
1462    /// with addSource() before using this function.
1463    ///
1464    /// \param em must be a bool (or convertible) arc map. The algorithm
1465    /// will stop when it reaches an arc \c e with <tt>em[e]</tt> true.
1466    ///
1467    ///\return The reached arc \c e with <tt>em[e]</tt> true or
1468    ///\c INVALID if no such arc was found.
1469    ///
1470    /// \warning Contrary to \ref Bfs and \ref Dijkstra, \c em is an arc map,
1471    /// not a node map.
1472    template <typename EM>
1473    Arc start(const EM &em) {
1474      while ( !emptyQueue() && !em[_stack[_stack_head]] )
1475        processNextArc();
1476      return emptyQueue() ? INVALID : _stack[_stack_head];
1477    }
1478
1479    /// \brief Runs %DFSVisit algorithm from node \c s.
1480    ///
1481    /// This method runs the %DFS algorithm from a root node \c s.
1482    /// \note d.run(s) is just a shortcut of the following code.
1483    ///\code
1484    ///   d.init();
1485    ///   d.addSource(s);
1486    ///   d.start();
1487    ///\endcode
1488    void run(Node s) {
1489      init();
1490      addSource(s);
1491      start();
1492    }
1493
1494    /// \brief Runs %DFSVisit algorithm to visit all nodes in the digraph.
1495   
1496    /// This method runs the %DFS algorithm in order to
1497    /// compute the %DFS path to each node. The algorithm computes
1498    /// - The %DFS tree.
1499    /// - The distance of each node from the root in the %DFS tree.
1500    ///
1501    ///\note d.run() is just a shortcut of the following code.
1502    ///\code
1503    ///  d.init();
1504    ///  for (NodeIt it(digraph); it != INVALID; ++it) {
1505    ///    if (!d.reached(it)) {
1506    ///      d.addSource(it);
1507    ///      d.start();
1508    ///    }
1509    ///  }
1510    ///\endcode
1511    void run() {
1512      init();
1513      for (NodeIt it(*_digraph); it != INVALID; ++it) {
1514        if (!reached(it)) {
1515          addSource(it);
1516          start();
1517        }
1518      }
1519    }
1520    ///@}
1521
1522    /// \name Query Functions
1523    /// The result of the %DFS algorithm can be obtained using these
1524    /// functions.\n
1525    /// Before the use of these functions,
1526    /// either run() or start() must be called.
1527    ///@{
1528    /// \brief Checks if a node is reachable from the root.
1529    ///
1530    /// Returns \c true if \c v is reachable from the root(s).
1531    /// \warning The source nodes are inditated as unreachable.
1532    /// \pre Either \ref run() or \ref start()
1533    /// must be called before using this function.
1534    ///
1535    bool reached(Node v) { return (*_reached)[v]; }
1536    ///@}
1537  };
1538
1539
1540} //END OF NAMESPACE LEMON
1541
1542#endif
1543
Note: See TracBrowser for help on using the repository browser.