Very small bug is corrected: if node creator tool is active, the small red arrows won't move, if you click on them and if you drag the newly created node... 'was hard to notice it :-)
2 * lemon/bfs.h - Part of LEMON, a generic C++ optimization library
4 * Copyright (C) 2005 Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
5 * (Egervary Research Group on Combinatorial Optimization, EGRES).
7 * Permission to use, modify and distribute this software is granted
8 * provided that this copyright notice appears in all copies. For
9 * precise terms see the accompanying LICENSE file.
11 * This software is provided "AS IS" with no warranty of any kind,
12 * express or implied, and with no claim as to its suitability for any
22 ///\brief Bfs algorithm.
24 #include <lemon/list_graph.h>
25 #include <lemon/graph_utils.h>
26 #include <lemon/invalid.h>
27 #include <lemon/error.h>
28 #include <lemon/maps.h>
34 ///Default traits class of Bfs class.
36 ///Default traits class of Bfs class.
37 ///\param GR Graph type.
39 struct BfsDefaultTraits
41 ///The graph type the algorithm runs on.
43 ///\brief The type of the map that stores the last
44 ///edges of the shortest paths.
46 ///The type of the map that stores the last
47 ///edges of the shortest paths.
48 ///It must meet the \ref concept::WriteMap "WriteMap" concept.
50 typedef typename Graph::template NodeMap<typename GR::Edge> PredMap;
51 ///Instantiates a PredMap.
53 ///This function instantiates a \ref PredMap.
54 ///\param G is the graph, to which we would like to define the PredMap.
55 ///\todo The graph alone may be insufficient to initialize
56 static PredMap *createPredMap(const GR &G)
58 return new PredMap(G);
60 // ///\brief The type of the map that stores the last but one
61 // ///nodes of the shortest paths.
63 // ///The type of the map that stores the last but one
64 // ///nodes of the shortest paths.
65 // ///It must meet the \ref concept::WriteMap "WriteMap" concept.
67 // typedef NullMap<typename Graph::Node,typename Graph::Node> PredNodeMap;
68 // ///Instantiates a PredNodeMap.
70 // ///This function instantiates a \ref PredNodeMap.
71 // ///\param G is the graph, to which
72 // ///we would like to define the \ref PredNodeMap
73 // static PredNodeMap *createPredNodeMap(const GR &G)
75 // return new PredNodeMap();
78 ///The type of the map that indicates which nodes are processed.
80 ///The type of the map that indicates which nodes are processed.
81 ///It must meet the \ref concept::WriteMap "WriteMap" concept.
82 ///\todo named parameter to set this type, function to read and write.
83 typedef NullMap<typename Graph::Node,bool> ProcessedMap;
84 ///Instantiates a ProcessedMap.
86 ///This function instantiates a \ref ProcessedMap.
87 ///\param G is the graph, to which
88 ///we would like to define the \ref ProcessedMap
89 static ProcessedMap *createProcessedMap(const GR &)
91 return new ProcessedMap();
93 ///The type of the map that indicates which nodes are reached.
95 ///The type of the map that indicates which nodes are reached.
96 ///It must meet the \ref concept::WriteMap "WriteMap" concept.
97 ///\todo named parameter to set this type, function to read and write.
98 typedef typename Graph::template NodeMap<bool> ReachedMap;
99 ///Instantiates a ReachedMap.
101 ///This function instantiates a \ref ReachedMap.
102 ///\param G is the graph, to which
103 ///we would like to define the \ref ReachedMap.
104 static ReachedMap *createReachedMap(const GR &G)
106 return new ReachedMap(G);
108 ///The type of the map that stores the dists of the nodes.
110 ///The type of the map that stores the dists of the nodes.
111 ///It must meet the \ref concept::WriteMap "WriteMap" concept.
113 typedef typename Graph::template NodeMap<int> DistMap;
114 ///Instantiates a DistMap.
116 ///This function instantiates a \ref DistMap.
117 ///\param G is the graph, to which we would like to define the \ref DistMap
118 static DistMap *createDistMap(const GR &G)
120 return new DistMap(G);
124 ///%BFS algorithm class.
127 ///This class provides an efficient implementation of the %BFS algorithm.
129 ///\param GR The graph type the algorithm runs on. The default value is
130 ///\ref ListGraph. The value of GR is not used directly by Bfs, it
131 ///is only passed to \ref BfsDefaultTraits.
132 ///\param TR Traits class to set various data types used by the algorithm.
133 ///The default traits class is
134 ///\ref BfsDefaultTraits "BfsDefaultTraits<GR>".
135 ///See \ref BfsDefaultTraits for the documentation of
136 ///a Bfs traits class.
138 ///\author Alpar Juttner
139 ///\todo A compare object would be nice.
142 template <typename GR,
145 template <typename GR=ListGraph,
146 typename TR=BfsDefaultTraits<GR> >
151 * \brief \ref Exception for uninitialized parameters.
153 * This error represents problems in the initialization
154 * of the parameters of the algorithms.
156 class UninitializedParameter : public lemon::UninitializedParameter {
158 virtual const char* exceptionName() const {
159 return "lemon::Bfs::UninitializedParameter";
164 ///The type of the underlying graph.
165 typedef typename TR::Graph Graph;
167 typedef typename Graph::Node Node;
169 typedef typename Graph::NodeIt NodeIt;
171 typedef typename Graph::Edge Edge;
173 typedef typename Graph::OutEdgeIt OutEdgeIt;
175 ///\brief The type of the map that stores the last
176 ///edges of the shortest paths.
177 typedef typename TR::PredMap PredMap;
178 // ///\brief The type of the map that stores the last but one
179 // ///nodes of the shortest paths.
180 // typedef typename TR::PredNodeMap PredNodeMap;
181 ///The type of the map indicating which nodes are reached.
182 typedef typename TR::ReachedMap ReachedMap;
183 ///The type of the map indicating which nodes are processed.
184 typedef typename TR::ProcessedMap ProcessedMap;
185 ///The type of the map that stores the dists of the nodes.
186 typedef typename TR::DistMap DistMap;
188 /// Pointer to the underlying graph.
190 ///Pointer to the map of predecessors edges.
192 ///Indicates if \ref _pred is locally allocated (\c true) or not.
194 // ///Pointer to the map of predecessors nodes.
195 // PredNodeMap *_predNode;
196 // ///Indicates if \ref _predNode is locally allocated (\c true) or not.
197 // bool local_predNode;
198 ///Pointer to the map of distances.
200 ///Indicates if \ref _dist is locally allocated (\c true) or not.
202 ///Pointer to the map of reached status of the nodes.
203 ReachedMap *_reached;
204 ///Indicates if \ref _reached is locally allocated (\c true) or not.
206 ///Pointer to the map of processed status of the nodes.
207 ProcessedMap *_processed;
208 ///Indicates if \ref _processed is locally allocated (\c true) or not.
209 bool local_processed;
211 std::vector<typename Graph::Node> _queue;
212 int _queue_head,_queue_tail,_queue_next_dist;
214 // ///The source node of the last execution.
217 ///Creates the maps if necessary.
219 ///\todo Error if \c G are \c NULL.
220 ///\todo Better memory allocation (instead of new).
225 _pred = Traits::createPredMap(*G);
228 // local_predNode = true;
229 // _predNode = Traits::createPredNodeMap(*G);
233 _dist = Traits::createDistMap(*G);
236 local_reached = true;
237 _reached = Traits::createReachedMap(*G);
240 local_processed = true;
241 _processed = Traits::createProcessedMap(*G);
247 ///\name Named template parameters
252 struct DefPredMapTraits : public Traits {
254 static PredMap *createPredMap(const Graph &G)
256 throw UninitializedParameter();
259 ///\ref named-templ-param "Named parameter" for setting PredMap type
261 ///\ref named-templ-param "Named parameter" for setting PredMap type
264 class DefPredMap : public Bfs< Graph,
265 DefPredMapTraits<T> > { };
267 // template <class T>
268 // struct DefPredNodeMapTraits : public Traits {
269 // typedef T PredNodeMap;
270 // static PredNodeMap *createPredNodeMap(const Graph &G)
272 // throw UninitializedParameter();
275 // ///\ref named-templ-param "Named parameter" for setting PredNodeMap type
277 // ///\ref named-templ-param "Named parameter" for setting PredNodeMap type
279 // template <class T>
280 // class DefPredNodeMap : public Bfs< Graph,
282 // DefPredNodeMapTraits<T> > { };
285 struct DefDistMapTraits : public Traits {
287 static DistMap *createDistMap(const Graph &G)
289 throw UninitializedParameter();
292 ///\ref named-templ-param "Named parameter" for setting DistMap type
294 ///\ref named-templ-param "Named parameter" for setting DistMap type
297 class DefDistMap : public Bfs< Graph,
298 DefDistMapTraits<T> > { };
301 struct DefReachedMapTraits : public Traits {
302 typedef T ReachedMap;
303 static ReachedMap *createReachedMap(const Graph &G)
305 throw UninitializedParameter();
308 ///\ref named-templ-param "Named parameter" for setting ReachedMap type
310 ///\ref named-templ-param "Named parameter" for setting ReachedMap type
313 class DefReachedMap : public Bfs< Graph,
314 DefReachedMapTraits<T> > { };
316 struct DefGraphReachedMapTraits : public Traits {
317 typedef typename Graph::template NodeMap<bool> ReachedMap;
318 static ReachedMap *createReachedMap(const Graph &G)
320 return new ReachedMap(G);
324 struct DefProcessedMapTraits : public Traits {
325 typedef T ProcessedMap;
326 static ProcessedMap *createProcessedMap(const Graph &G)
328 throw UninitializedParameter();
331 ///\ref named-templ-param "Named parameter" for setting ProcessedMap type
333 ///\ref named-templ-param "Named parameter" for setting ProcessedMap type
336 class DefProcessedMap : public Bfs< Graph,
337 DefProcessedMapTraits<T> > { };
339 struct DefGraphProcessedMapTraits : public Traits {
340 typedef typename Graph::template NodeMap<bool> ProcessedMap;
341 static ProcessedMap *createProcessedMap(const Graph &G)
343 return new ProcessedMap(G);
346 ///\brief \ref named-templ-param "Named parameter"
347 ///for setting the ProcessedMap type to be Graph::NodeMap<bool>.
349 ///\ref named-templ-param "Named parameter"
350 ///for setting the ProcessedMap type to be Graph::NodeMap<bool>.
351 ///If you don't set it explicitly, it will be automatically allocated.
353 class DefProcessedMapToBeDefaultMap :
355 DefGraphProcessedMapTraits> { };
363 ///\param _G the graph the algorithm will run on.
365 Bfs(const Graph& _G) :
367 _pred(NULL), local_pred(false),
368 // _predNode(NULL), local_predNode(false),
369 _dist(NULL), local_dist(false),
370 _reached(NULL), local_reached(false),
371 _processed(NULL), local_processed(false)
377 if(local_pred) delete _pred;
378 // if(local_predNode) delete _predNode;
379 if(local_dist) delete _dist;
380 if(local_reached) delete _reached;
381 if(local_processed) delete _processed;
384 ///Sets the map storing the predecessor edges.
386 ///Sets the map storing the predecessor edges.
387 ///If you don't use this function before calling \ref run(),
388 ///it will allocate one. The destructor deallocates this
389 ///automatically allocated map, of course.
390 ///\return <tt> (*this) </tt>
391 Bfs &predMap(PredMap &m)
401 ///Sets the map indicating the reached nodes.
403 ///Sets the map indicating the reached nodes.
404 ///If you don't use this function before calling \ref run(),
405 ///it will allocate one. The destructor deallocates this
406 ///automatically allocated map, of course.
407 ///\return <tt> (*this) </tt>
408 Bfs &reachedMap(ReachedMap &m)
418 ///Sets the map indicating the processed nodes.
420 ///Sets the map indicating the processed nodes.
421 ///If you don't use this function before calling \ref run(),
422 ///it will allocate one. The destructor deallocates this
423 ///automatically allocated map, of course.
424 ///\return <tt> (*this) </tt>
425 Bfs &processedMap(ProcessedMap &m)
427 if(local_processed) {
429 local_processed=false;
435 // ///Sets the map storing the predecessor nodes.
437 // ///Sets the map storing the predecessor nodes.
438 // ///If you don't use this function before calling \ref run(),
439 // ///it will allocate one. The destructor deallocates this
440 // ///automatically allocated map, of course.
441 // ///\return <tt> (*this) </tt>
442 // Bfs &predNodeMap(PredNodeMap &m)
444 // if(local_predNode) {
446 // local_predNode=false;
452 ///Sets the map storing the distances calculated by the algorithm.
454 ///Sets the map storing the distances calculated by the algorithm.
455 ///If you don't use this function before calling \ref run(),
456 ///it will allocate one. The destructor deallocates this
457 ///automatically allocated map, of course.
458 ///\return <tt> (*this) </tt>
459 Bfs &distMap(DistMap &m)
470 ///\name Execution control
471 ///The simplest way to execute the algorithm is to use
472 ///one of the member functions called \c run(...).
474 ///If you need more control on the execution,
475 ///first you must call \ref init(), then you can add several source nodes
476 ///with \ref addSource().
477 ///Finally \ref start() will perform the actual path
482 ///Initializes the internal data structures.
484 ///Initializes the internal data structures.
489 _queue.resize(countNodes(*G));
490 _queue_head=_queue_tail=0;
492 for ( NodeIt u(*G) ; u!=INVALID ; ++u ) {
493 _pred->set(u,INVALID);
494 // _predNode->set(u,INVALID);
495 _reached->set(u,false);
496 _processed->set(u,false);
500 ///Adds a new source node.
502 ///Adds a new source node to the set of nodes to be processed.
504 void addSource(Node s)
508 _reached->set(s,true);
509 _pred->set(s,INVALID);
511 _queue[_queue_head++]=s;
512 _queue_next_dist=_queue_head;
516 ///Processes the next node.
518 ///Processes the next node.
520 ///\warning The queue must not be empty!
521 void processNextNode()
523 if(_queue_tail==_queue_next_dist) {
525 _queue_next_dist=_queue_head;
527 Node n=_queue[_queue_tail++];
528 _processed->set(n,true);
530 for(OutEdgeIt e(*G,n);e!=INVALID;++e)
531 if(!(*_reached)[m=G->target(e)]) {
532 _queue[_queue_head++]=m;
533 _reached->set(m,true);
535 // _pred_node->set(m,n);
536 _dist->set(m,_curr_dist);
540 ///\brief Returns \c false if there are nodes
541 ///to be processed in the queue
543 ///Returns \c false if there are nodes
544 ///to be processed in the queue
545 bool emptyQueue() { return _queue_tail==_queue_head; }
546 ///Returns the number of the nodes to be processed.
548 ///Returns the number of the nodes to be processed in the queue.
550 int queueSize() { return _queue_head-_queue_tail; }
552 ///Executes the algorithm.
554 ///Executes the algorithm.
556 ///\pre init() must be called and at least one node should be added
557 ///with addSource() before using this function.
559 ///This method runs the %BFS algorithm from the root node(s)
562 ///shortest path to each node. The algorithm computes
563 ///- The shortest path tree.
564 ///- The distance of each node from the root(s).
568 while ( !emptyQueue() ) processNextNode();
571 ///Executes the algorithm until \c dest is reached.
573 ///Executes the algorithm until \c dest is reached.
575 ///\pre init() must be called and at least one node should be added
576 ///with addSource() before using this function.
578 ///This method runs the %BFS algorithm from the root node(s)
581 ///shortest path to \c dest. The algorithm computes
582 ///- The shortest path to \c dest.
583 ///- The distance of \c dest from the root(s).
585 void start(Node dest)
587 while ( !emptyQueue() && _queue[_queue_tail]!=dest ) processNextNode();
590 ///Executes the algorithm until a condition is met.
592 ///Executes the algorithm until a condition is met.
594 ///\pre init() must be called and at least one node should be added
595 ///with addSource() before using this function.
597 ///\param nm must be a bool (or convertible) node map. The algorithm
598 ///will stop when it reaches a node \c v with <tt>nm[v]==true</tt>.
600 void start(const NM &nm)
602 while ( !emptyQueue() && !nm[_queue[_queue_tail]] ) processNextNode();
605 ///Runs %BFS algorithm from node \c s.
607 ///This method runs the %BFS algorithm from a root node \c s
610 ///shortest path to each node. The algorithm computes
611 ///- The shortest path tree.
612 ///- The distance of each node from the root.
614 ///\note d.run(s) is just a shortcut of the following code.
626 ///Finds the shortest path between \c s and \c t.
628 ///Finds the shortest path between \c s and \c t.
630 ///\return The length of the shortest s---t path if there exists one,
632 ///\note Apart from the return value, d.run(s) is
633 ///just a shortcut of the following code.
639 int run(Node s,Node t) {
643 return reached(t)?_curr_dist-1+(_queue_tail==_queue_next_dist):0;
648 ///\name Query Functions
649 ///The result of the %BFS algorithm can be obtained using these
651 ///Before the use of these functions,
652 ///either run() or start() must be called.
656 ///Copies the shortest path to \c t into \c p
658 ///This function copies the shortest path to \c t into \c p.
659 ///If it \c \t is a source itself or unreachable, then it does not
661 ///\todo Is it the right way to handle unreachable nodes?
662 ///\return Returns \c true if a path to \c t was actually copied to \c p,
663 ///\c false otherwise.
666 bool getPath(P &p,Node t)
670 typename P::Builder b(p);
671 for(b.setStartNode(t);pred(t)!=INVALID;t=predNode(t))
672 b.pushFront(pred(t));
679 ///The distance of a node from the root(s).
681 ///Returns the distance of a node from the root(s).
682 ///\pre \ref run() must be called before using this function.
683 ///\warning If node \c v in unreachable from the root(s) the return value
684 ///of this function is undefined.
685 int dist(Node v) const { return (*_dist)[v]; }
687 ///Returns the 'previous edge' of the shortest path tree.
689 ///For a node \c v it returns the 'previous edge'
690 ///of the shortest path tree,
691 ///i.e. it returns the last edge of a shortest path from the root(s) to \c
692 ///v. It is \ref INVALID
693 ///if \c v is unreachable from the root(s) or \c v is a root. The
694 ///shortest path tree used here is equal to the shortest path tree used in
695 ///\ref predNode(Node v).
696 ///\pre Either \ref run() or \ref start() must be called before using
698 ///\todo predEdge could be a better name.
699 Edge pred(Node v) const { return (*_pred)[v];}
701 ///Returns the 'previous node' of the shortest path tree.
703 ///For a node \c v it returns the 'previous node'
704 ///of the shortest path tree,
705 ///i.e. it returns the last but one node from a shortest path from the
707 ///It is INVALID if \c v is unreachable from the root(s) or
708 ///if \c v itself a root.
709 ///The shortest path tree used here is equal to the shortest path
710 ///tree used in \ref pred(Node v).
711 ///\pre Either \ref run() or \ref start() must be called before
712 ///using this function.
713 Node predNode(Node v) const { return (*_pred)[v]==INVALID ? INVALID:
714 G->source((*_pred)[v]); }
716 ///Returns a reference to the NodeMap of distances.
718 ///Returns a reference to the NodeMap of distances.
719 ///\pre Either \ref run() or \ref init() must
720 ///be called before using this function.
721 const DistMap &distMap() const { return *_dist;}
723 ///Returns a reference to the shortest path tree map.
725 ///Returns a reference to the NodeMap of the edges of the
726 ///shortest path tree.
727 ///\pre Either \ref run() or \ref init()
728 ///must be called before using this function.
729 const PredMap &predMap() const { return *_pred;}
731 // ///Returns a reference to the map of nodes of shortest paths.
733 // ///Returns a reference to the NodeMap of the last but one nodes of the
734 // ///shortest path tree.
735 // ///\pre \ref run() must be called before using this function.
736 // const PredNodeMap &predNodeMap() const { return *_predNode;}
738 ///Checks if a node is reachable from the root.
740 ///Returns \c true if \c v is reachable from the root.
741 ///\warning The source nodes are indicated as unreached.
742 ///\pre Either \ref run() or \ref start()
743 ///must be called before using this function.
745 bool reached(Node v) { return (*_reached)[v]; }
750 ///Default traits class of Bfs function.
752 ///Default traits class of Bfs function.
753 ///\param GR Graph type.
755 struct BfsWizardDefaultTraits
757 ///The graph type the algorithm runs on.
759 ///\brief The type of the map that stores the last
760 ///edges of the shortest paths.
762 ///The type of the map that stores the last
763 ///edges of the shortest paths.
764 ///It must meet the \ref concept::WriteMap "WriteMap" concept.
766 typedef NullMap<typename Graph::Node,typename GR::Edge> PredMap;
767 ///Instantiates a PredMap.
769 ///This function instantiates a \ref PredMap.
770 ///\param G is the graph, to which we would like to define the PredMap.
771 ///\todo The graph alone may be insufficient to initialize
772 static PredMap *createPredMap(const GR &)
774 return new PredMap();
776 // ///\brief The type of the map that stores the last but one
777 // ///nodes of the shortest paths.
779 // ///The type of the map that stores the last but one
780 // ///nodes of the shortest paths.
781 // ///It must meet the \ref concept::WriteMap "WriteMap" concept.
783 // typedef NullMap<typename Graph::Node,typename Graph::Node> PredNodeMap;
784 // ///Instantiates a PredNodeMap.
786 // ///This function instantiates a \ref PredNodeMap.
787 // ///\param G is the graph, to which
788 // ///we would like to define the \ref PredNodeMap
789 // static PredNodeMap *createPredNodeMap(const GR &G)
791 // return new PredNodeMap();
794 ///The type of the map that indicates which nodes are processed.
796 ///The type of the map that indicates which nodes are processed.
797 ///It must meet the \ref concept::WriteMap "WriteMap" concept.
798 ///\todo named parameter to set this type, function to read and write.
799 typedef NullMap<typename Graph::Node,bool> ProcessedMap;
800 ///Instantiates a ProcessedMap.
802 ///This function instantiates a \ref ProcessedMap.
803 ///\param G is the graph, to which
804 ///we would like to define the \ref ProcessedMap
805 static ProcessedMap *createProcessedMap(const GR &)
807 return new ProcessedMap();
809 ///The type of the map that indicates which nodes are reached.
811 ///The type of the map that indicates which nodes are reached.
812 ///It must meet the \ref concept::WriteMap "WriteMap" concept.
813 ///\todo named parameter to set this type, function to read and write.
814 typedef typename Graph::template NodeMap<bool> ReachedMap;
815 ///Instantiates a ReachedMap.
817 ///This function instantiates a \ref ReachedMap.
818 ///\param G is the graph, to which
819 ///we would like to define the \ref ReachedMap.
820 static ReachedMap *createReachedMap(const GR &G)
822 return new ReachedMap(G);
824 ///The type of the map that stores the dists of the nodes.
826 ///The type of the map that stores the dists of the nodes.
827 ///It must meet the \ref concept::WriteMap "WriteMap" concept.
829 typedef NullMap<typename Graph::Node,int> DistMap;
830 ///Instantiates a DistMap.
832 ///This function instantiates a \ref DistMap.
833 ///\param G is the graph, to which we would like to define the \ref DistMap
834 static DistMap *createDistMap(const GR &)
836 return new DistMap();
840 /// Default traits used by \ref BfsWizard
842 /// To make it easier to use Bfs algorithm
843 ///we have created a wizard class.
844 /// This \ref BfsWizard class needs default traits,
845 ///as well as the \ref Bfs class.
846 /// The \ref BfsWizardBase is a class to be the default traits of the
847 /// \ref BfsWizard class.
849 class BfsWizardBase : public BfsWizardDefaultTraits<GR>
852 typedef BfsWizardDefaultTraits<GR> Base;
854 /// Type of the nodes in the graph.
855 typedef typename Base::Graph::Node Node;
857 /// Pointer to the underlying graph.
859 ///Pointer to the map of reached nodes.
861 ///Pointer to the map of processed nodes.
863 ///Pointer to the map of predecessors edges.
865 // ///Pointer to the map of predecessors nodes.
867 ///Pointer to the map of distances.
869 ///Pointer to the source node.
875 /// This constructor does not require parameters, therefore it initiates
876 /// all of the attributes to default values (0, INVALID).
877 BfsWizardBase() : _g(0), _reached(0), _processed(0), _pred(0),
879 _dist(0), _source(INVALID) {}
883 /// This constructor requires some parameters,
884 /// listed in the parameters list.
885 /// Others are initiated to 0.
886 /// \param g is the initial value of \ref _g
887 /// \param s is the initial value of \ref _source
888 BfsWizardBase(const GR &g, Node s=INVALID) :
889 _g((void *)&g), _reached(0), _processed(0), _pred(0),
891 _dist(0), _source(s) {}
895 /// A class to make the usage of Bfs algorithm easier
897 /// This class is created to make it easier to use Bfs algorithm.
898 /// It uses the functions and features of the plain \ref Bfs,
899 /// but it is much simpler to use it.
901 /// Simplicity means that the way to change the types defined
902 /// in the traits class is based on functions that returns the new class
903 /// and not on templatable built-in classes.
904 /// When using the plain \ref Bfs
905 /// the new class with the modified type comes from
906 /// the original class by using the ::
907 /// operator. In the case of \ref BfsWizard only
908 /// a function have to be called and it will
909 /// return the needed class.
911 /// It does not have own \ref run method. When its \ref run method is called
912 /// it initiates a plain \ref Bfs class, and calls the \ref Bfs::run
915 class BfsWizard : public TR
919 ///The type of the underlying graph.
920 typedef typename TR::Graph Graph;
922 typedef typename Graph::Node Node;
924 typedef typename Graph::NodeIt NodeIt;
926 typedef typename Graph::Edge Edge;
928 typedef typename Graph::OutEdgeIt OutEdgeIt;
930 ///\brief The type of the map that stores
932 typedef typename TR::ReachedMap ReachedMap;
933 ///\brief The type of the map that stores
934 ///the processed nodes
935 typedef typename TR::ProcessedMap ProcessedMap;
936 ///\brief The type of the map that stores the last
937 ///edges of the shortest paths.
938 typedef typename TR::PredMap PredMap;
939 // ///\brief The type of the map that stores the last but one
940 // ///nodes of the shortest paths.
941 // typedef typename TR::PredNodeMap PredNodeMap;
942 ///The type of the map that stores the dists of the nodes.
943 typedef typename TR::DistMap DistMap;
947 BfsWizard() : TR() {}
949 /// Constructor that requires parameters.
951 /// Constructor that requires parameters.
952 /// These parameters will be the default values for the traits class.
953 BfsWizard(const Graph &g, Node s=INVALID) :
957 BfsWizard(const TR &b) : TR(b) {}
961 ///Runs Bfs algorithm from a given node.
963 ///Runs Bfs algorithm from a given node.
964 ///The node can be given by the \ref source function.
967 if(Base::_source==INVALID) throw UninitializedParameter();
968 Bfs<Graph,TR> alg(*(Graph*)Base::_g);
970 alg.reachedMap(*(ReachedMap*)Base::_reached);
971 if(Base::_processed) alg.processedMap(*(ProcessedMap*)Base::_processed);
972 if(Base::_pred) alg.predMap(*(PredMap*)Base::_pred);
973 // if(Base::_predNode) alg.predNodeMap(*(PredNodeMap*)Base::_predNode);
974 if(Base::_dist) alg.distMap(*(DistMap*)Base::_dist);
975 alg.run(Base::_source);
978 ///Runs Bfs algorithm from the given node.
980 ///Runs Bfs algorithm from the given node.
981 ///\param s is the given source.
989 struct DefPredMapBase : public Base {
991 static PredMap *createPredMap(const Graph &) { return 0; };
992 DefPredMapBase(const TR &b) : TR(b) {}
995 ///\brief \ref named-templ-param "Named parameter"
996 ///function for setting PredMap
998 /// \ref named-templ-param "Named parameter"
999 ///function for setting PredMap
1002 BfsWizard<DefPredMapBase<T> > predMap(const T &t)
1004 Base::_pred=(void *)&t;
1005 return BfsWizard<DefPredMapBase<T> >(*this);
1010 struct DefReachedMapBase : public Base {
1011 typedef T ReachedMap;
1012 static ReachedMap *createReachedMap(const Graph &) { return 0; };
1013 DefReachedMapBase(const TR &b) : TR(b) {}
1016 ///\brief \ref named-templ-param "Named parameter"
1017 ///function for setting ReachedMap
1019 /// \ref named-templ-param "Named parameter"
1020 ///function for setting ReachedMap
1023 BfsWizard<DefReachedMapBase<T> > reachedMap(const T &t)
1025 Base::_pred=(void *)&t;
1026 return BfsWizard<DefReachedMapBase<T> >(*this);
1031 struct DefProcessedMapBase : public Base {
1032 typedef T ProcessedMap;
1033 static ProcessedMap *createProcessedMap(const Graph &) { return 0; };
1034 DefProcessedMapBase(const TR &b) : TR(b) {}
1037 ///\brief \ref named-templ-param "Named parameter"
1038 ///function for setting ProcessedMap
1040 /// \ref named-templ-param "Named parameter"
1041 ///function for setting ProcessedMap
1044 BfsWizard<DefProcessedMapBase<T> > processedMap(const T &t)
1046 Base::_pred=(void *)&t;
1047 return BfsWizard<DefProcessedMapBase<T> >(*this);
1051 // template<class T>
1052 // struct DefPredNodeMapBase : public Base {
1053 // typedef T PredNodeMap;
1054 // static PredNodeMap *createPredNodeMap(const Graph &G) { return 0; };
1055 // DefPredNodeMapBase(const TR &b) : TR(b) {}
1058 // ///\brief \ref named-templ-param "Named parameter"
1059 // ///function for setting PredNodeMap type
1061 // /// \ref named-templ-param "Named parameter"
1062 // ///function for setting PredNodeMap type
1064 // template<class T>
1065 // BfsWizard<DefPredNodeMapBase<T> > predNodeMap(const T &t)
1067 // Base::_predNode=(void *)&t;
1068 // return BfsWizard<DefPredNodeMapBase<T> >(*this);
1072 struct DefDistMapBase : public Base {
1074 static DistMap *createDistMap(const Graph &) { return 0; };
1075 DefDistMapBase(const TR &b) : TR(b) {}
1078 ///\brief \ref named-templ-param "Named parameter"
1079 ///function for setting DistMap type
1081 /// \ref named-templ-param "Named parameter"
1082 ///function for setting DistMap type
1085 BfsWizard<DefDistMapBase<T> > distMap(const T &t)
1087 Base::_dist=(void *)&t;
1088 return BfsWizard<DefDistMapBase<T> >(*this);
1091 /// Sets the source node, from which the Bfs algorithm runs.
1093 /// Sets the source node, from which the Bfs algorithm runs.
1094 /// \param s is the source node.
1095 BfsWizard<TR> &source(Node s)
1103 ///Function type interface for Bfs algorithm.
1105 /// \ingroup flowalgs
1106 ///Function type interface for Bfs algorithm.
1108 ///This function also has several
1109 ///\ref named-templ-func-param "named parameters",
1110 ///they are declared as the members of class \ref BfsWizard.
1112 ///example shows how to use these parameters.
1114 /// bfs(g,source).predMap(preds).run();
1116 ///\warning Don't forget to put the \ref BfsWizard::run() "run()"
1117 ///to the end of the parameter list.
1121 BfsWizard<BfsWizardBase<GR> >
1122 bfs(const GR &g,typename GR::Node s=INVALID)
1124 return BfsWizard<BfsWizardBase<GR> >(g,s);
1127 } //END OF NAMESPACE LEMON