lemon-1.2: comparison lemon/bfs.h

equal deleted inserted replaced

-:8b8b64daffd7
+:6fa540fd26b4
 #include <lemon/list_graph.h>
 #include <lemon/bits/path_dump.h>
 #include <lemon/core.h>
 #include <lemon/error.h>
 #include <lemon/maps.h>
+#include <lemon/path.h>
 namespace lemon {
 ///Default traits class of Bfs class.
 ///%BFS algorithm class.
 ///\ingroup search
 ///This class provides an efficient implementation of the %BFS algorithm.
 ///
-///There is also a \ref bfs() "function type interface" for the BFS
+///There is also a \ref bfs() "function-type interface" for the BFS
 ///algorithm, which is convenient in the simplier cases and it can be
 ///used easier.
 ///
 ///\tparam GR The type of the digraph the algorithm runs on.
 ///The default value is \ref ListDigraph. The value of GR is not used
 ///arcs of the shortest paths.
 ///
 ///The type of the map that stores the predecessor
 ///arcs of the shortest paths.
 ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
-typedef NullMap<typename Digraph::Node,typename Digraph::Arc> PredMap;
+typedef typename Digraph::template NodeMap<typename Digraph::Arc> PredMap;
 ///Instantiates a \ref PredMap.
 ///This function instantiates a \ref PredMap.
 ///\param g is the digraph, to which we would like to define the
 ///\ref PredMap.
 ///\todo The digraph alone may be insufficient to initialize
-#ifdef DOXYGEN
 static PredMap *createPredMap(const Digraph &g)
-#else
+{
-static PredMap *createPredMap(const Digraph &)
+return new PredMap(g);
-#endif
-{
-return new PredMap();
 }
 ///The type of the map that indicates which nodes are processed.
 ///The type of the map that indicates which nodes are processed.
 ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
+///By default it is a NullMap.
 typedef NullMap<typename Digraph::Node,bool> ProcessedMap;
 ///Instantiates a \ref ProcessedMap.
 ///This function instantiates a \ref ProcessedMap.
 ///\param g is the digraph, to which
 ///The type of the map that stores the distances of the nodes.
 ///The type of the map that stores the distances of the nodes.
 ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
-///
+typedef typename Digraph::template NodeMap<int> DistMap;
-typedef NullMap<typename Digraph::Node,int> DistMap;
 ///Instantiates a \ref DistMap.
 ///This function instantiates a \ref DistMap.
 ///\param g is the digraph, to which we would like to define
 ///the \ref DistMap
-#ifdef DOXYGEN
 static DistMap *createDistMap(const Digraph &g)
-#else
+{
-static DistMap *createDistMap(const Digraph &)
+return new DistMap(g);
-#endif
+}
-{
-return new DistMap();
+///The type of the shortest paths.
-}
+///The type of the shortest paths.
+///It must meet the \ref concepts::Path "Path" concept.
+typedef lemon::Path<Digraph> Path;
 };
 /// Default traits class used by \ref BfsWizard
 /// To make it easier to use Bfs algorithm
 void *_processed;
 //Pointer to the map of predecessors arcs.
 void *_pred;
 //Pointer to the map of distances.
 void *_dist;
-//Pointer to the source node.
+//Pointer to the shortest path to the target node.
-Node _source;
+void *_path;
+//Pointer to the distance of the target node.
+int *_di;
 public:
 /// Constructor.
 /// This constructor does not require parameters, therefore it initiates
-/// all of the attributes to default values (0, INVALID).
+/// all of the attributes to \c 0.
 BfsWizardBase() : _g(0), _reached(0), _processed(0), _pred(0),
-_dist(0), _source(INVALID) {}
+_dist(0), _path(0), _di(0) {}
 /// Constructor.
-/// This constructor requires some parameters,
+/// This constructor requires one parameter,
-/// listed in the parameters list.
+/// others are initiated to \c 0.
-/// Others are initiated to 0.
 /// \param g The digraph the algorithm runs on.
-/// \param s The source node.
+BfsWizardBase(const GR &g) :
-BfsWizardBase(const GR &g, Node s=INVALID) :
 _g(reinterpret_cast<void*>(const_cast<GR*>(&g))),
-_reached(0), _processed(0), _pred(0), _dist(0), _source(s) {}
+_reached(0), _processed(0), _pred(0), _dist(0),  _path(0), _di(0) {}
 };
-/// Auxiliary class for the function type interface of BFS algorithm.
+/// Auxiliary class for the function-type interface of BFS algorithm.
-/// This auxiliary class is created to implement the function type
+/// This auxiliary class is created to implement the
-/// interface of \ref Bfs algorithm. It uses the functions and features
+/// \ref bfs() "function-type interface" of \ref Bfs algorithm.
-/// of the plain \ref Bfs, but it is much simpler to use it.
+/// It does not have own \ref run() method, it uses the functions
-/// It should only be used through the \ref bfs() function, which makes
+/// and features of the plain \ref Bfs.
-/// it easier to use the algorithm.
 ///
-/// Simplicity means that the way to change the types defined
+/// This class should only be used through the \ref bfs() function,
-/// in the traits class is based on functions that returns the new class
+/// which makes it easier to use the algorithm.
-/// and not on templatable built-in classes.
-/// When using the plain \ref Bfs
-/// the new class with the modified type comes from
-/// the original class by using the ::
-/// operator. In the case of \ref BfsWizard only
-/// a function have to be called, and it will
-/// return the needed class.
-///
-/// It does not have own \ref run() method. When its \ref run() method
-/// is called, it initiates a plain \ref Bfs object, and calls the
-/// \ref Bfs::run() method of it.
 template<class TR>
 class BfsWizard : public TR
 {
 typedef TR Base;
 typedef typename TR::DistMap DistMap;
 ///\brief The type of the map that indicates which nodes are reached.
 typedef typename TR::ReachedMap ReachedMap;
 ///\brief The type of the map that indicates which nodes are processed.
 typedef typename TR::ProcessedMap ProcessedMap;
+///The type of the shortest paths
+typedef typename TR::Path Path;
 public:
 /// Constructor.
 BfsWizard() : TR() {}
 /// Constructor that requires parameters.
 /// Constructor that requires parameters.
 /// These parameters will be the default values for the traits class.
-BfsWizard(const Digraph &g, Node s=INVALID) :
+/// \param g The digraph the algorithm runs on.
-TR(g,s) {}
+BfsWizard(const Digraph &g) :
+TR(g) {}
 ///Copy constructor
 BfsWizard(const TR &b) : TR(b) {}
 ~BfsWizard() {}
-///Runs BFS algorithm from a source node.
+///Runs BFS algorithm from the given source node.
-///Runs BFS algorithm from a source node.
+///This method runs BFS algorithm from node \c s
-///The node can be given with the \ref source() function.
+///in order to compute the shortest path to each node.
+void run(Node s)
+{
+Bfs<Digraph,TR> alg(*reinterpret_cast<const Digraph*>(Base::_g));
+if (Base::_pred)
+alg.predMap(*reinterpret_cast<PredMap*>(Base::_pred));
+if (Base::_dist)
+alg.distMap(*reinterpret_cast<DistMap*>(Base::_dist));
+if (Base::_reached)
+alg.reachedMap(*reinterpret_cast<ReachedMap*>(Base::_reached));
+if (Base::_processed)
+alg.processedMap(*reinterpret_cast<ProcessedMap*>(Base::_processed));
+if (s!=INVALID)
+alg.run(s);
+else
+alg.run();
+}
+///Finds the shortest path between \c s and \c t.
+///This method runs BFS algorithm from node \c s
+///in order to compute the shortest path to node \c t
+///(it stops searching when \c t is processed).
+///
+///\return \c true if \c t is reachable form \c s.
+bool run(Node s, Node t)
+{
+if (s==INVALID || t==INVALID) throw UninitializedParameter();
+Bfs<Digraph,TR> alg(*reinterpret_cast<const Digraph*>(Base::_g));
+if (Base::_pred)
+alg.predMap(*reinterpret_cast<PredMap*>(Base::_pred));
+if (Base::_dist)
+alg.distMap(*reinterpret_cast<DistMap*>(Base::_dist));
+if (Base::_reached)
+alg.reachedMap(*reinterpret_cast<ReachedMap*>(Base::_reached));
+if (Base::_processed)
+alg.processedMap(*reinterpret_cast<ProcessedMap*>(Base::_processed));
+alg.run(s,t);
+if (Base::_path)
+*reinterpret_cast<Path*>(Base::_path) = alg.path(t);
+if (Base::_di)
+*Base::_di = alg.dist(t);
+return alg.reached(t);
+}
+///Runs BFS algorithm to visit all nodes in the digraph.
+///This method runs BFS algorithm in order to compute
+///the shortest path to each node.
 void run()
 {
-if(Base::_source==INVALID) throw UninitializedParameter();
+run(INVALID);
-Bfs<Digraph,TR> alg(*reinterpret_cast<const Digraph*>(Base::_g));
-if(Base::_reached)
-alg.reachedMap(*reinterpret_cast<ReachedMap*>(Base::_reached));
-if(Base::_processed)
-alg.processedMap(*reinterpret_cast<ProcessedMap*>(Base::_processed));
-if(Base::_pred)
-alg.predMap(*reinterpret_cast<PredMap*>(Base::_pred));
-if(Base::_dist)
-alg.distMap(*reinterpret_cast<DistMap*>(Base::_dist));
-alg.run(Base::_source);
-}
-///Runs BFS algorithm from the given node.
-///Runs BFS algorithm from the given node.
-///\param s is the given source.
-void run(Node s)
-{
-Base::_source=s;
-run();
-}
-/// Sets the source node, from which the Bfs algorithm runs.
-/// Sets the source node, from which the Bfs algorithm runs.
-/// \param s is the source node.
-BfsWizard<TR> &source(Node s)
-{
-Base::_source=s;
-return *this;
 }
 template<class T>
 struct SetPredMapBase : public Base {
 typedef T PredMap;
 static PredMap *createPredMap(const Digraph &) { return 0; };
 SetPredMapBase(const TR &b) : TR(b) {}
 };
-///\brief \ref named-templ-param "Named parameter"
+///\brief \ref named-func-param "Named parameter"
 ///for setting \ref PredMap object.
 ///
-/// \ref named-templ-param "Named parameter"
+///\ref named-func-param "Named parameter"
 ///for setting \ref PredMap object.
 template<class T>
 BfsWizard<SetPredMapBase<T> > predMap(const T &t)
 {
 Base::_pred=reinterpret_cast<void*>(const_cast<T*>(&t));
 struct SetReachedMapBase : public Base {
 typedef T ReachedMap;
 static ReachedMap *createReachedMap(const Digraph &) { return 0; };
 SetReachedMapBase(const TR &b) : TR(b) {}
 };
-///\brief \ref named-templ-param "Named parameter"
+///\brief \ref named-func-param "Named parameter"
 ///for setting \ref ReachedMap object.
 ///
-/// \ref named-templ-param "Named parameter"
+/// \ref named-func-param "Named parameter"
 ///for setting \ref ReachedMap object.
 template<class T>
 BfsWizard<SetReachedMapBase<T> > reachedMap(const T &t)
 {
 Base::_reached=reinterpret_cast<void*>(const_cast<T*>(&t));
 return BfsWizard<SetReachedMapBase<T> >(*this);
+}
+template<class T>
+struct SetDistMapBase : public Base {
+typedef T DistMap;
+static DistMap *createDistMap(const Digraph &) { return 0; };
+SetDistMapBase(const TR &b) : TR(b) {}
+};
+///\brief \ref named-func-param "Named parameter"
+///for setting \ref DistMap object.
+///
+/// \ref named-func-param "Named parameter"
+///for setting \ref DistMap object.
+template<class T>
+BfsWizard<SetDistMapBase<T> > distMap(const T &t)
+{
+Base::_dist=reinterpret_cast<void*>(const_cast<T*>(&t));
+return BfsWizard<SetDistMapBase<T> >(*this);
 }
 template<class T>
 struct SetProcessedMapBase : public Base {
 typedef T ProcessedMap;
 static ProcessedMap *createProcessedMap(const Digraph &) { return 0; };
 SetProcessedMapBase(const TR &b) : TR(b) {}
 };
-///\brief \ref named-templ-param "Named parameter"
+///\brief \ref named-func-param "Named parameter"
 ///for setting \ref ProcessedMap object.
 ///
-/// \ref named-templ-param "Named parameter"
+/// \ref named-func-param "Named parameter"
 ///for setting \ref ProcessedMap object.
 template<class T>
 BfsWizard<SetProcessedMapBase<T> > processedMap(const T &t)
 {
 Base::_processed=reinterpret_cast<void*>(const_cast<T*>(&t));
 return BfsWizard<SetProcessedMapBase<T> >(*this);
 }
 template<class T>
-struct SetDistMapBase : public Base {
+struct SetPathBase : public Base {
-typedef T DistMap;
+typedef T Path;
-static DistMap *createDistMap(const Digraph &) { return 0; };
+SetPathBase(const TR &b) : TR(b) {}
-SetDistMapBase(const TR &b) : TR(b) {}
+};
-};
+///\brief \ref named-func-param "Named parameter"
-///\brief \ref named-templ-param "Named parameter"
+///for getting the shortest path to the target node.
-///for setting \ref DistMap object.
+///
-///
+///\ref named-func-param "Named parameter"
-/// \ref named-templ-param "Named parameter"
+///for getting the shortest path to the target node.
-///for setting \ref DistMap object.
 template<class T>
-BfsWizard<SetDistMapBase<T> > distMap(const T &t)
+BfsWizard<SetPathBase<T> > path(const T &t)
 {
-Base::_dist=reinterpret_cast<void*>(const_cast<T*>(&t));
+Base::_path=reinterpret_cast<void*>(const_cast<T*>(&t));
-return BfsWizard<SetDistMapBase<T> >(*this);
+return BfsWizard<SetPathBase<T> >(*this);
+}
+///\brief \ref named-func-param "Named parameter"
+///for getting the distance of the target node.
+///
+///\ref named-func-param "Named parameter"
+///for getting the distance of the target node.
+BfsWizard dist(const int &d)
+{
+Base::_di=const_cast<int*>(&d);
+return *this;
 }
 };
-///Function type interface for Bfs algorithm.
+///Function-type interface for BFS algorithm.
 /// \ingroup search
-///Function type interface for Bfs algorithm.
+///Function-type interface for BFS algorithm.
 ///
-///This function also has several
+///This function also has several \ref named-func-param "named parameters",
-///\ref named-templ-func-param "named parameters",
 ///they are declared as the members of class \ref BfsWizard.
-///The following
+///The following examples show how to use these parameters.
-///example shows how to use these parameters.
 ///\code
-///  bfs(g,source).predMap(preds).run();
+///  // Compute shortest path from node s to each node
+///  bfs(g).predMap(preds).distMap(dists).run(s);
+///
+///  // Compute shortest path from s to t
+///  bool reached = bfs(g).path(p).dist(d).run(s,t);
 ///\endcode
 ///\warning Don't forget to put the \ref BfsWizard::run() "run()"
 ///to the end of the parameter list.
 ///\sa BfsWizard
 ///\sa Bfs
 template<class GR>
 BfsWizard<BfsWizardBase<GR> >
-bfs(const GR &g,typename GR::Node s=INVALID)
+bfs(const GR &digraph)
 {
-return BfsWizard<BfsWizardBase<GR> >(g,s);
+return BfsWizard<BfsWizardBase<GR> >(digraph);
 }
 #ifdef DOXYGEN
 /// \brief Visitor class for BFS.
 ///

changeset 282	dc9e8d2c0df9
parent 258	0310c8984732
child 281	e9b4fbe163f5
child 286	da414906fe21