Ticket #96: dijk_4a3bfa4577a5.patch

lemon/bfs.h

@@ -28 +28 @@
 #include <lemon/core.h>
 #include <lemon/error.h>
 #include <lemon/maps.h>
+#include <lemon/path.h>
 
 namespace lemon {
 
@@ -841 +842 @@
     ///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 &)
-#endif
     {
-      return new PredMap();
+      return new PredMap(g);
     }
 
     ///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.
 
@@ -895 +893 @@
 
     ///The type of the map that stores the distances of the nodes.
     ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
-    ///
-    typedef NullMap<typename Digraph::Node,int> DistMap;
+    typedef typename Digraph::template NodeMap<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 &)
-#endif
     {
-      return new DistMap();
+      return new DistMap(g);
     }
+
+    ///The type of the shortest paths.
+
+    ///The type of the shortest paths.
+    ///It must meet the \ref concepts::Path "Path" concept.
+    typedef lemon::Path<Digraph> Path;
   };
 
   /// Default traits class used by \ref BfsWizard
@@ -939 +938 @@
     void *_pred;
     //Pointer to the map of distances.
     void *_dist;
-    //Pointer to the source node.
+    //Pointer to the shortest path to the target node.
+    void *_path;
+    //Pointer to the distance of the target node.
+    int *_di;
+    //The source node.
     Node _source;
+    //The the target node.
+    Node _target;
 
     public:
     /// Constructor.
@@ -948 +953 @@
     /// This constructor does not require parameters, therefore it initiates
     /// all of the attributes to default values (0, INVALID).
     BfsWizardBase() : _g(0), _reached(0), _processed(0), _pred(0),
-                      _dist(0), _source(INVALID) {}
+                      _dist(0), _path(0), _di(0),
+                      _source(INVALID), _target(INVALID) {}
 
     /// Constructor.
 
@@ -957 +963 @@
     /// Others are initiated to 0.
     /// \param g The digraph the algorithm runs on.
     /// \param s The source node.
-    BfsWizardBase(const GR &g, Node s=INVALID) :
+    /// \param t The optional target node.
+    BfsWizardBase(const GR &g, Node s, Node t=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),
+      _source(s), _target(t) {}
 
   };
 
@@ -1006 +1014 @@
     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:
 
@@ -1016 +1026 @@
 
     /// Constructor that requires parameters.
     /// These parameters will be the default values for the traits class.
-    BfsWizard(const Digraph &g, Node s=INVALID) :
-      TR(g,s) {}
+    /// \param g The digraph the algorithm runs on.
+    /// \param s The source node.
+    /// \param t The optional target node.
+    BfsWizard(const Digraph &g, Node s, Node t=INVALID) :
+      TR(g,s,t) {}
 
     ///Copy constructor
     BfsWizard(const TR &b) : TR(b) {}
 
     ~BfsWizard() {}
 
-    ///Runs BFS algorithm from a source node.
+    ///Runs BFS algorithm from the source node.
 
-    ///Runs BFS algorithm from a source node.
-    ///The node can be given with the \ref source() function.
-    void run()
+    ///This function runs BFS algorithm from the source node that
+    ///was given in the constructor.
+    ///If a target node is given, the function computes the shortest
+    ///path to that node (it stops the search when it reaches that
+    ///node), otherwise it computes the shortest path to each node.
+    ///\param t The optional target node.
+    ///\return \c true if no target node was given (so the function
+    ///computed the shortest path to each reachable node) or if the
+    ///given target node was reached.
+    bool run(Node t=INVALID)
     {
+      if(t!=INVALID) Base::_target=t;
       if(Base::_source==INVALID) throw UninitializedParameter();
       Bfs<Digraph,TR> alg(*reinterpret_cast<const Digraph*>(Base::_g));
       if(Base::_reached)
@@ -1040 +1061 @@
         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;
+      if(Base::_target!=INVALID) {
+        alg.run(Base::_source, Base::_target);
+        if (Base::_path)
+          *reinterpret_cast<Path*>(Base::_path) = alg.path(Base::_target);
+        if (Base::_di)
+          *Base::_di = alg.dist(Base::_target);
+        return alg.reached(Base::_target);
+      } else {
+        alg.run(Base::_source);
+        return true;
+      }
     }
 
     template<class T>
@@ -1100 +1111 @@
     }
 
     template<class T>
+    struct SetDistMapBase : public Base {
+      typedef T DistMap;
+      static DistMap *createDistMap(const Digraph &) { return 0; };
+      SetDistMapBase(const TR &b) : TR(b) {}
+    };
+    ///\brief \ref named-templ-param "Named parameter"
+    ///for setting \ref DistMap object.
+    ///
+    /// \ref named-templ-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; };
@@ -1118 +1147 @@
     }
 
     template<class T>
-    struct SetDistMapBase : public Base {
-      typedef T DistMap;
-      static DistMap *createDistMap(const Digraph &) { return 0; };
-      SetDistMapBase(const TR &b) : TR(b) {}
+    struct SetPathBase : public Base {
+      typedef T Path;
+      SetPathBase(const TR &b) : TR(b) {}
     };
     ///\brief \ref named-templ-param "Named parameter"
-    ///for setting \ref DistMap object.
+    ///for getting the shortest path to the target node.
     ///
-    /// \ref named-templ-param "Named parameter"
-    ///for setting \ref DistMap object.
+    ///\ref named-templ-param "Named parameter"
+    ///for getting the shortest path to the target node.
     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));
-      return BfsWizard<SetDistMapBase<T> >(*this);
+      Base::_path=reinterpret_cast<void*>(const_cast<T*>(&t));
+      return BfsWizard<SetPathBase<T> >(*this);
+    }
+
+    ///\brief \ref named-templ-param "Named parameter"
+    ///for getting the distance of the target node.
+    ///
+    ///\ref named-templ-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
   ///\ref named-templ-func-param "named parameters",
   ///they are declared as the members of class \ref BfsWizard.
-  ///The following
-  ///example shows how to use these parameters.
+  ///The following examples show how to use these parameters.
   ///\code
-  ///  bfs(g,source).predMap(preds).run();
+  ///  // Compute shortest path to each node
+  ///  bfs(g,source).predMap(preds).distMap(dists).run();
+  ///
+  ///  // Compute shortest path to one node
+  ///  bool reached = bfs(g,source,target).path(p).dist(d).run();
   ///\endcode
   ///\warning Don't forget to put the \ref BfsWizard::run() "run()"
   ///to the end of the parameter list.
@@ -1156 +1198 @@
   ///\sa Bfs
   template<class GR>
   BfsWizard<BfsWizardBase<GR> >
-  bfs(const GR &g,typename GR::Node s=INVALID)
+  bfs(const GR &digraph,
+      typename GR::Node source, typename GR::Node target=INVALID)
   {
-    return BfsWizard<BfsWizardBase<GR> >(g,s);
+    return BfsWizard<BfsWizardBase<GR> >(digraph,source,target);
   }
 
 #ifdef DOXYGEN

lemon/concepts/path.h

@@ -66 +66 @@
 
       /// \brief Template assigment
       template <typename CPath>
-      Path& operator=(const CPath& cpath) {}
+      Path& operator=(const CPath& cpath) {
+        ignore_unused_variable_warning(cpath);
+        return *this;
+      }
 
       /// Length of the path ie. the number of arcs in the path.
       int length() const { return 0;}

lemon/dfs.h

@@ -29 +29 @@
 #include <lemon/error.h>
 #include <lemon/assert.h>
 #include <lemon/maps.h>
+#include <lemon/path.h>
 
 namespace lemon {
 
@@ -775 +776 @@
     ///The type of the map that stores the predecessor
     ///arcs of the %DFS 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 &)
-#endif
     {
-      return new PredMap();
+      return new PredMap(g);
     }
 
     ///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.
 
@@ -830 +827 @@
 
     ///The type of the map that stores the distances of the nodes.
     ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
-    ///
-    typedef NullMap<typename Digraph::Node,int> DistMap;
+    typedef typename Digraph::template NodeMap<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 &)
-#endif
     {
-      return new DistMap();
+      return new DistMap(g);
     }
+
+    ///The type of the DFS paths.
+
+    ///The type of the DFS paths.
+    ///It must meet the \ref concepts::Path "Path" concept.
+    typedef lemon::Path<Digraph> Path;
   };
 
   /// Default traits class used by \ref DfsWizard
@@ -874 +872 @@
     void *_pred;
     //Pointer to the map of distances.
     void *_dist;
-    //Pointer to the source node.
+    //Pointer to the DFS path to the target node.
+    void *_path;
+    //Pointer to the distance of the target node.
+    int *_di;
+    //The source node.
     Node _source;
+    //The the target node.
+    Node _target;
 
     public:
     /// Constructor.
@@ -883 +887 @@
     /// This constructor does not require parameters, therefore it initiates
     /// all of the attributes to default values (0, INVALID).
     DfsWizardBase() : _g(0), _reached(0), _processed(0), _pred(0),
-                      _dist(0), _source(INVALID) {}
+                      _dist(0), _path(0), _di(0),
+                      _source(INVALID), _target(INVALID) {}
 
     /// Constructor.
 
@@ -892 +897 @@
     /// Others are initiated to 0.
     /// \param g The digraph the algorithm runs on.
     /// \param s The source node.
-    DfsWizardBase(const GR &g, Node s=INVALID) :
+    /// \param t The optional target node.
+    DfsWizardBase(const GR &g, Node s, Node t=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),
+      _source(s), _target(t) {}
 
   };
 
@@ -933 +940 @@
     typedef typename Digraph::OutArcIt OutArcIt;
 
     ///\brief The type of the map that stores the predecessor
-    ///arcs of the shortest paths.
+    ///arcs of the DFS paths.
     typedef typename TR::PredMap PredMap;
     ///\brief The type of the map that stores the distances of the nodes.
     typedef typename TR::DistMap DistMap;
@@ -941 +948 @@
     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 DFS paths
+    typedef typename TR::Path Path;
 
   public:
 
@@ -951 +960 @@
 
     /// Constructor that requires parameters.
     /// These parameters will be the default values for the traits class.
-    DfsWizard(const Digraph &g, Node s=INVALID) :
-      TR(g,s) {}
+    /// \param g The digraph the algorithm runs on.
+    /// \param s The source node.
+    /// \param t The optional target node.
+    DfsWizard(const Digraph &g, Node s, Node t=INVALID) :
+      TR(g,s,t) {}
 
     ///Copy constructor
     DfsWizard(const TR &b) : TR(b) {}
 
     ~DfsWizard() {}
 
-    ///Runs DFS algorithm from a source node.
+    ///Runs DFS algorithm from the source node.
 
-    ///Runs DFS algorithm from a source node.
-    ///The node can be given with the \ref source() function.
-    void run()
+    ///This function runs DFS algorithm from the source node that
+    ///was given in the constructor.
+    ///If a target node is given, the function computes the DFS
+    ///path to that node (it stops the search when it reaches that
+    ///node), otherwise it computes the DFS path to each node.
+    ///\param t The optional target node.
+    ///\return \c true if no target node was given (so the function
+    ///computed the DFS path to each reachable node) or if the
+    ///given target node was reached.
+    bool run(Node t=INVALID)
     {
+      if(t!=INVALID) Base::_target=t;
       if(Base::_source==INVALID) throw UninitializedParameter();
       Dfs<Digraph,TR> alg(*reinterpret_cast<const Digraph*>(Base::_g));
       if(Base::_reached)
@@ -975 +995 @@
         alg.predMap(*reinterpret_cast<PredMap*>(Base::_pred));
       if(Base::_dist)
         alg.distMap(*reinterpret_cast<DistMap*>(Base::_dist));
-      alg.run(Base::_source);
-    }
-
-    ///Runs DFS algorithm from the given node.
-
-    ///Runs DFS 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 Dfs algorithm runs.
-
-    /// Sets the source node, from which the Dfs algorithm runs.
-    /// \param s is the source node.
-    DfsWizard<TR> &source(Node s)
-    {
-      Base::_source=s;
-      return *this;
+      if(Base::_target!=INVALID) {
+        alg.run(Base::_source, Base::_target);
+        if (Base::_path)
+          *reinterpret_cast<Path*>(Base::_path) = alg.path(Base::_target);
+        if (Base::_di)
+          *Base::_di = alg.dist(Base::_target);
+        return alg.reached(Base::_target);
+      } else {
+        alg.run(Base::_source);
+        return true;
+      }
     }
 
     template<class T>
@@ -1035 +1045 @@
     }
 
     template<class T>
+    struct SetDistMapBase : public Base {
+      typedef T DistMap;
+      static DistMap *createDistMap(const Digraph &) { return 0; };
+      SetDistMapBase(const TR &b) : TR(b) {}
+    };
+    ///\brief \ref named-templ-param "Named parameter"
+    ///for setting \ref DistMap object.
+    ///
+    ///\ref named-templ-param "Named parameter"
+    ///for setting \ref DistMap object.
+    template<class T>
+    DfsWizard<SetDistMapBase<T> > distMap(const T &t)
+    {
+      Base::_dist=reinterpret_cast<void*>(const_cast<T*>(&t));
+      return DfsWizard<SetDistMapBase<T> >(*this);
+    }
+
+    template<class T>
     struct SetProcessedMapBase : public Base {
       typedef T ProcessedMap;
       static ProcessedMap *createProcessedMap(const Digraph &) { return 0; };
@@ -1053 +1081 @@
     }
 
     template<class T>
-    struct SetDistMapBase : public Base {
-      typedef T DistMap;
-      static DistMap *createDistMap(const Digraph &) { return 0; };
-      SetDistMapBase(const TR &b) : TR(b) {}
+    struct SetPathBase : public Base {
+      typedef T Path;
+      SetPathBase(const TR &b) : TR(b) {}
     };
     ///\brief \ref named-templ-param "Named parameter"
-    ///for setting \ref DistMap object.
+    ///for getting the DFS path to the target node.
     ///
     ///\ref named-templ-param "Named parameter"
-    ///for setting \ref DistMap object.
+    ///for getting the DFS path to the target node.
     template<class T>
-    DfsWizard<SetDistMapBase<T> > distMap(const T &t)
+    DfsWizard<SetPathBase<T> > path(const T &t)
     {
-      Base::_dist=reinterpret_cast<void*>(const_cast<T*>(&t));
-      return DfsWizard<SetDistMapBase<T> >(*this);
+      Base::_path=reinterpret_cast<void*>(const_cast<T*>(&t));
+      return DfsWizard<SetPathBase<T> >(*this);
+    }
+
+    ///\brief \ref named-templ-param "Named parameter"
+    ///for getting the distance of the target node.
+    ///
+    ///\ref named-templ-param "Named parameter"
+    ///for getting the distance of the target node.
+    DfsWizard dist(const int &d)
+    {
+      Base::_di=const_cast<int*>(&d);
+      return *this;
     }
 
   };
 
-  ///Function type interface for Dfs algorithm.
+  ///Function type interface for DFS algorithm.
 
   ///\ingroup search
-  ///Function type interface for Dfs algorithm.
+  ///Function type interface for DFS algorithm.
   ///
   ///This function also has several
   ///\ref named-templ-func-param "named parameters",
   ///they are declared as the members of class \ref DfsWizard.
-  ///The following
-  ///example shows how to use these parameters.
+  ///The following examples show how to use these parameters.
   ///\code
-  ///  dfs(g,source).predMap(preds).run();
+  ///  // Compute the DFS tree
+  ///  dfs(g,source).predMap(preds).distMap(dists).run();
+  ///
+  ///  // Compute the DFS path to one node
+  ///  bool reached = dfs(g,source,target).path(p).dist(d).run();
   ///\endcode
+
   ///\warning Don't forget to put the \ref DfsWizard::run() "run()"
   ///to the end of the parameter list.
   ///\sa DfsWizard
   ///\sa Dfs
   template<class GR>
   DfsWizard<DfsWizardBase<GR> >
-  dfs(const GR &g,typename GR::Node s=INVALID)
+  dfs(const GR &digraph,
+      typename GR::Node source, typename GR::Node target=INVALID)
   {
-    return DfsWizard<DfsWizardBase<GR> >(g,s);
+    return DfsWizard<DfsWizardBase<GR> >(digraph,source,target);
   }
 
 #ifdef DOXYGEN

lemon/dijkstra.h

@@ -30 +30 @@
 #include <lemon/core.h>
 #include <lemon/error.h>
 #include <lemon/maps.h>
+#include <lemon/path.h>
 
 namespace lemon {
 
@@ -987 +988 @@
     ///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 &)
-#endif
     {
-      return new PredMap();
+      return new PredMap(g);
     }
 
     ///The type of the map that indicates which nodes are processed.
@@ -1030 +1027 @@
 
     ///The type of the map that stores the distances of the nodes.
     ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
-    typedef NullMap<typename Digraph::Node,Value> DistMap;
+    typedef typename Digraph::template NodeMap<typename LM::Value> 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 &)
-#endif
     {
-      return new DistMap();
+      return new DistMap(g);
     }
+
+    ///The type of the shortest paths.
+
+    ///The type of the shortest paths.
+    ///It must meet the \ref concepts::Path "Path" concept.
+    typedef lemon::Path<Digraph> Path;
   };
 
   /// Default traits class used by \ref DijkstraWizard
@@ -1065 +1064 @@
 
     //Pointer to the digraph the algorithm runs on.
     void *_g;
-    //Pointer to the length map
+    //Pointer to the length map.
     void *_length;
     //Pointer to the map of processed nodes.
     void *_processed;
@@ -1073 +1072 @@
     void *_pred;
     //Pointer to the map of distances.
     void *_dist;
-    //Pointer to the source node.
+    //Pointer to the shortest path to the target node.
+    void *_path;
+    //Pointer to the distance of the target node.
+    void *_di;
+    //The source node.
     Node _source;
+    //The target node.
+    Node _target;
 
   public:
     /// Constructor.
@@ -1082 +1087 @@
     /// This constructor does not require parameters, therefore it initiates
     /// all of the attributes to default values (0, INVALID).
     DijkstraWizardBase() : _g(0), _length(0), _processed(0), _pred(0),
-                           _dist(0), _source(INVALID) {}
+                           _dist(0), _path(0), _di(0),
+                           _source(INVALID), _target(INVALID) {}
 
     /// Constructor.
 
@@ -1092 +1098 @@
     /// \param g The digraph the algorithm runs on.
     /// \param l The length map.
     /// \param s The source node.
-    DijkstraWizardBase(const GR &g,const LM &l, Node s=INVALID) :
+    /// \param t The optional target node.
+    DijkstraWizardBase(const GR &g,const LM &l, Node s, Node t=INVALID) :
       _g(reinterpret_cast<void*>(const_cast<GR*>(&g))),
       _length(reinterpret_cast<void*>(const_cast<LM*>(&l))),
-      _processed(0), _pred(0), _dist(0), _source(s) {}
+      _processed(0), _pred(0), _dist(0), _path(0), _di(0),
+      _source(s), _target(t) {}
 
   };
 
@@ -1144 +1152 @@
     typedef typename TR::DistMap DistMap;
     ///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;
     ///The heap type used by the dijkstra algorithm.
     typedef typename TR::Heap Heap;
 
@@ -1156 +1166 @@
 
     /// Constructor that requires parameters.
     /// These parameters will be the default values for the traits class.
-    DijkstraWizard(const Digraph &g,const LengthMap &l, Node s=INVALID) :
-      TR(g,l,s) {}
+    /// \param g The digraph the algorithm runs on.
+    /// \param l The length map.
+    /// \param s The source node.
+    /// \param t The optional target node.
+    DijkstraWizard(const Digraph &g, const LengthMap &l,
+                   Node s, Node t=INVALID) :
+      TR(g,l,s,t) {}
 
     ///Copy constructor
     DijkstraWizard(const TR &b) : TR(b) {}
 
     ~DijkstraWizard() {}
 
-    ///Runs Dijkstra algorithm from a source node.
+    ///Runs Dijkstra algorithm from the source node.
 
-    ///Runs Dijkstra algorithm from a source node.
-    ///The node can be given with the \ref source() function.
-    void run()
+    ///This function runs Dijkstra algorithm from the source node that
+    ///was given in the constructor.
+    ///If a target node is given, the function computes the shortest
+    ///path to that node (it stops the search when it processes that
+    ///node), otherwise it computes the shortest path to each node.
+    ///\param t The optional target node.
+    ///\return \c true if no target node was given (so the function
+    ///computed the shortest path to each reachable node) or if the
+    ///given target node was reached.
+    bool run(Node t=INVALID)
     {
+      if(t!=INVALID) Base::_target=t;
       if(Base::_source==INVALID) throw UninitializedParameter();
       Dijkstra<Digraph,LengthMap,TR>
-        dij(*reinterpret_cast<const Digraph*>(Base::_g),
-            *reinterpret_cast<const LengthMap*>(Base::_length));
+        dijk(*reinterpret_cast<const Digraph*>(Base::_g),
+             *reinterpret_cast<const LengthMap*>(Base::_length));
       if(Base::_processed)
-        dij.processedMap(*reinterpret_cast<ProcessedMap*>(Base::_processed));
+        dijk.processedMap(*reinterpret_cast<ProcessedMap*>(Base::_processed));
       if(Base::_pred)
-        dij.predMap(*reinterpret_cast<PredMap*>(Base::_pred));
+        dijk.predMap(*reinterpret_cast<PredMap*>(Base::_pred));
       if(Base::_dist)
-        dij.distMap(*reinterpret_cast<DistMap*>(Base::_dist));
-      dij.run(Base::_source);
-    }
-
-    ///Runs Dijkstra algorithm from the given node.
-
-    ///Runs Dijkstra 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 Dijkstra algorithm runs.
-
-    /// Sets the source node, from which the Dijkstra algorithm runs.
-    /// \param s is the source node.
-    DijkstraWizard<TR> &source(Node s)
-    {
-      Base::_source=s;
-      return *this;
+        dijk.distMap(*reinterpret_cast<DistMap*>(Base::_dist));
+      if(Base::_target!=INVALID) {
+        dijk.run(Base::_source, Base::_target);
+        if (Base::_path)
+          *reinterpret_cast<Path*>(Base::_path) = dijk.path(Base::_target);
+        if (Base::_di)
+          *reinterpret_cast<Value*>(Base::_di) = dijk.dist(Base::_target);
+        return dijk.reached(Base::_target);
+      } else {
+        dijk.run(Base::_source);
+        return true;
+      }
     }
 
     template<class T>
@@ -1222 +1235 @@
     }
 
     template<class T>
+    struct SetDistMapBase : public Base {
+      typedef T DistMap;
+      static DistMap *createDistMap(const Digraph &) { return 0; };
+      SetDistMapBase(const TR &b) : TR(b) {}
+    };
+    ///\brief \ref named-templ-param "Named parameter"
+    ///for setting \ref DistMap object.
+    ///
+    ///\ref named-templ-param "Named parameter"
+    ///for setting \ref DistMap object.
+    template<class T>
+    DijkstraWizard<SetDistMapBase<T> > distMap(const T &t)
+    {
+      Base::_dist=reinterpret_cast<void*>(const_cast<T*>(&t));
+      return DijkstraWizard<SetDistMapBase<T> >(*this);
+    }
+
+    template<class T>
     struct SetProcessedMapBase : public Base {
       typedef T ProcessedMap;
       static ProcessedMap *createProcessedMap(const Digraph &) { return 0; };
@@ -1240 +1271 @@
     }
 
     template<class T>
-    struct SetDistMapBase : public Base {
-      typedef T DistMap;
-      static DistMap *createDistMap(const Digraph &) { return 0; };
-      SetDistMapBase(const TR &b) : TR(b) {}
+    struct SetPathBase : public Base {
+      typedef T Path;
+      SetPathBase(const TR &b) : TR(b) {}
     };
     ///\brief \ref named-templ-param "Named parameter"
-    ///for setting \ref DistMap object.
+    ///for getting the shortest path to the target node.
     ///
     ///\ref named-templ-param "Named parameter"
-    ///for setting \ref DistMap object.
+    ///for getting the shortest path to the target node.
     template<class T>
-    DijkstraWizard<SetDistMapBase<T> > distMap(const T &t)
+    DijkstraWizard<SetPathBase<T> > path(const T &t)
     {
-      Base::_dist=reinterpret_cast<void*>(const_cast<T*>(&t));
-      return DijkstraWizard<SetDistMapBase<T> >(*this);
+      Base::_path=reinterpret_cast<void*>(const_cast<T*>(&t));
+      return DijkstraWizard<SetPathBase<T> >(*this);
+    }
+
+    ///\brief \ref named-templ-param "Named parameter"
+    ///for getting the distance of the target node.
+    ///
+    ///\ref named-templ-param "Named parameter"
+    ///for getting the distance of the target node.
+    DijkstraWizard dist(const Value &d)
+    {
+      Base::_di=reinterpret_cast<void*>(const_cast<Value*>(&d));
+      return *this;
     }
 
   };
@@ -1267 +1308 @@
   ///This function also has several
   ///\ref named-templ-func-param "named parameters",
   ///they are declared as the members of class \ref DijkstraWizard.
-  ///The following
-  ///example shows how to use these parameters.
+  ///The following examples show how to use these parameters.
   ///\code
-  ///  dijkstra(g,length,source).predMap(preds).run();
+  ///  // Compute shortest path to each node
+  ///  dijkstra(g,length,source).predMap(preds).distMap(dists).run();
+  ///
+  ///  // Compute shortest path to one node
+  ///  bool reached = dijkstra(g,length,source,target).path(p).dist(d).run();
   ///\endcode
   ///\warning Don't forget to put the \ref DijkstraWizard::run() "run()"
   ///to the end of the parameter list.
@@ -1278 +1322 @@
   ///\sa Dijkstra
   template<class GR, class LM>
   DijkstraWizard<DijkstraWizardBase<GR,LM> >
-  dijkstra(const GR &g,const LM &l,typename GR::Node s=INVALID)
+  dijkstra(const GR &digraph, const LM &length,
+           typename GR::Node source, typename GR::Node target=INVALID)
   {
-    return DijkstraWizard<DijkstraWizardBase<GR,LM> >(g,l,s);
+    return DijkstraWizard<DijkstraWizardBase<GR,LM> >(digraph,length,
+                                                      source,target);
   }
 
 } //END OF NAMESPACE LEMON

test/bfs_test.cc

@@ -62 +62 @@
   bool b;
   BType::DistMap d(G);
   BType::PredMap p(G);
-  //  BType::PredNodeMap pn(G);
 
   BType bfs_test(G);
 
@@ -72 +71 @@
   e  = bfs_test.predArc(n);
   n  = bfs_test.predNode(n);
   d  = bfs_test.distMap();
-
   p  = bfs_test.predMap();
-  //  pn = bfs_test.predNodeMap();
   b  = bfs_test.reached(n);
 
   Path<Digraph> pp = bfs_test.path(n);
@@ -89 +86 @@
 
   Digraph g;
   bfs(g,Node()).run();
-  bfs(g).source(Node()).run();
-  bfs(g)
-    .predMap(concepts::WriteMap<Node,Arc>())
-    .distMap(concepts::WriteMap<Node,VType>())
-    .reachedMap(concepts::ReadWriteMap<Node,bool>())
+  bfs(g,Node())
+    .predMap(concepts::ReadWriteMap<Node,Arc>())
+    .distMap(concepts::ReadWriteMap<Node,VType>())
     .processedMap(concepts::WriteMap<Node,bool>())
+    .run();
+  bfs(g,Node(),Node())
+    .predMap(concepts::ReadWriteMap<Node,Arc>())
+    .distMap(concepts::ReadWriteMap<Node,VType>())
+    .processedMap(concepts::WriteMap<Node,bool>())
+    .path(concepts::Path<Digraph>()).dist(VType())
+    .run();
+  bfs(g,Node())
+    .predMap(concepts::ReadWriteMap<Node,Arc>())
+    .distMap(concepts::ReadWriteMap<Node,VType>())
+    .processedMap(concepts::WriteMap<Node,bool>())
+    .path(concepts::Path<Digraph>()).dist(VType())
     .run(Node());
 }
 
@@ -114 +121 @@
   Bfs<Digraph> bfs_test(G);
   bfs_test.run(s);
 
-  check(bfs_test.dist(t)==2,"Bfs found a wrong path." << bfs_test.dist(t));
+  check(bfs_test.dist(t)==2,"Bfs found a wrong path.");
 
   Path<Digraph> p = bfs_test.path(t);
   check(p.length()==2,"path() found a wrong path.");
@@ -128 +135 @@
     Node v=G.target(a);
     check( !bfs_test.reached(u) ||
            (bfs_test.dist(v) <= bfs_test.dist(u)+1),
-           "Wrong output." << G.id(v) << ' ' << G.id(u));
+           "Wrong output. " << G.id(u) << "->" << G.id(v));
   }
 
   for(NodeIt v(G); v!=INVALID; ++v) {
@@ -140 +147 @@
         check(u==bfs_test.predNode(v),"Wrong tree.");
         check(bfs_test.dist(v) - bfs_test.dist(u) == 1,
               "Wrong distance. Difference: "
-              << std::abs(bfs_test.dist(v) - bfs_test.dist(u)
-                          - 1));
+              << std::abs(bfs_test.dist(v) - bfs_test.dist(u) - 1));
       }
     }
+  }
+
+  {
+    NullMap<Node,Arc> myPredMap;
+    bfs(G,s).predMap(myPredMap).run();
   }
 }
 

test/dfs_test.cc

@@ -89 +89 @@
 
   Digraph g;
   dfs(g,Node()).run();
-  dfs(g).source(Node()).run();
-  dfs(g)
-    .predMap(concepts::WriteMap<Node,Arc>())
-    .distMap(concepts::WriteMap<Node,VType>())
-    .reachedMap(concepts::ReadWriteMap<Node,bool>())
+  dfs(g,Node())
+    .predMap(concepts::ReadWriteMap<Node,Arc>())
+    .distMap(concepts::ReadWriteMap<Node,VType>())
     .processedMap(concepts::WriteMap<Node,bool>())
+    .run();
+  dfs(g,Node(),Node())
+    .predMap(concepts::ReadWriteMap<Node,Arc>())
+    .distMap(concepts::ReadWriteMap<Node,VType>())
+    .processedMap(concepts::WriteMap<Node,bool>())
+    .path(concepts::Path<Digraph>()).dist(VType())
+    .run();
+  dfs(g,Node())
+    .predMap(concepts::ReadWriteMap<Node,Arc>())
+    .distMap(concepts::ReadWriteMap<Node,VType>())
+    .processedMap(concepts::WriteMap<Node,bool>())
+    .path(concepts::Path<Digraph>()).dist(VType())
     .run(Node());
 }
 
@@ -129 +139 @@
         check(u==dfs_test.predNode(v),"Wrong tree.");
         check(dfs_test.dist(v) - dfs_test.dist(u) == 1,
               "Wrong distance. (" << dfs_test.dist(u) << "->"
-              <<dfs_test.dist(v) << ')');
+              << dfs_test.dist(v) << ")");
       }
     }
+  }
+
+  {
+    NullMap<Node,Arc> myPredMap;
+    dfs(G,s).predMap(myPredMap).run();
   }
 }
 

test/dijkstra_test.cc

@@ -64 +64 @@
   bool b;
   DType::DistMap d(G);
   DType::PredMap p(G);
-  //  DType::PredNodeMap pn(G);
   LengthMap length;
 
   DType dijkstra_test(G,length);
@@ -76 +75 @@
   n  = dijkstra_test.predNode(n);
   d  = dijkstra_test.distMap();
   p  = dijkstra_test.predMap();
-  //  pn = dijkstra_test.predNodeMap();
   b  = dijkstra_test.reached(n);
 
   Path<Digraph> pp = dijkstra_test.path(n);
@@ -92 +90 @@
 
   Digraph g;
   dijkstra(g,LengthMap(),Node()).run();
-  dijkstra(g,LengthMap()).source(Node()).run();
-  dijkstra(g,LengthMap())
-    .predMap(concepts::WriteMap<Node,Arc>())
-    .distMap(concepts::WriteMap<Node,VType>())
+  dijkstra(g,LengthMap(),Node())
+    .predMap(concepts::ReadWriteMap<Node,Arc>())
+    .distMap(concepts::ReadWriteMap<Node,VType>())
+    .processedMap(concepts::WriteMap<Node,bool>())
+    .run();
+  dijkstra(g,LengthMap(),Node(),Node())
+    .predMap(concepts::ReadWriteMap<Node,Arc>())
+    .distMap(concepts::ReadWriteMap<Node,VType>())
+    .processedMap(concepts::WriteMap<Node,bool>())
+    .path(concepts::Path<Digraph>()).dist(VType())
+    .run();
+  dijkstra(g,LengthMap(),Node())
+    .predMap(concepts::ReadWriteMap<Node,Arc>())
+    .distMap(concepts::ReadWriteMap<Node,VType>())
+    .processedMap(concepts::WriteMap<Node,bool>())
+    .path(concepts::Path<Digraph>()).dist(VType())
     .run(Node());
 }
 
@@ -122 +132 @@
   check(dijkstra_test.dist(t)==3,"Dijkstra found a wrong path.");
 
   Path<Digraph> p = dijkstra_test.path(t);
-  check(p.length()==3,"getPath() found a wrong path.");
+  check(p.length()==3,"path() found a wrong path.");
   check(checkPath(G, p),"path() found a wrong path.");
   check(pathSource(G, p) == s,"path() found a wrong path.");
   check(pathTarget(G, p) == t,"path() found a wrong path.");
@@ -132 +142 @@
     Node v=G.target(e);
     check( !dijkstra_test.reached(u) ||
            (dijkstra_test.dist(v) - dijkstra_test.dist(u) <= length[e]),
-           "dist(target)-dist(source)-arc_length= " <<
+           "Wrong output. dist(target)-dist(source)-arc_length=" <<
            dijkstra_test.dist(v) - dijkstra_test.dist(u) - length[e]);
   }
 
@@ -152 +162 @@
 
   {
     NullMap<Node,Arc> myPredMap;
-    dijkstra(G,length).predMap(myPredMap).run(s);
+    dijkstra(G,length,s).predMap(myPredMap).run();
   }
 }