COIN-OR::LEMON - Graph Library

source: lemon-1.2/lemon/dijkstra.h @ 247:f1158744a112

Last change on this file since 247:f1158744a112 was 247:f1158744a112, checked in by Alpar Juttner <alpar@…>, 11 years ago

Merge

File size: 42.0 KB
Line 
1/* -*- mode: C++; indent-tabs-mode: nil; -*-
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_DIJKSTRA_H
20#define LEMON_DIJKSTRA_H
21
22///\ingroup shortest_path
23///\file
24///\brief Dijkstra algorithm.
25
26#include <limits>
27#include <lemon/list_graph.h>
28#include <lemon/bin_heap.h>
29#include <lemon/bits/path_dump.h>
30#include <lemon/core.h>
31#include <lemon/error.h>
32#include <lemon/maps.h>
33
34namespace lemon {
35
36  /// \brief Default operation traits for the Dijkstra algorithm class.
37  ///
38  /// This operation traits class defines all computational operations and
39  /// constants which are used in the Dijkstra algorithm.
40  template <typename Value>
41  struct DijkstraDefaultOperationTraits {
42    /// \brief Gives back the zero value of the type.
43    static Value zero() {
44      return static_cast<Value>(0);
45    }
46    /// \brief Gives back the sum of the given two elements.
47    static Value plus(const Value& left, const Value& right) {
48      return left + right;
49    }
50    /// \brief Gives back true only if the first value is less than the second.
51    static bool less(const Value& left, const Value& right) {
52      return left < right;
53    }
54  };
55
56  /// \brief Widest path operation traits for the Dijkstra algorithm class.
57  ///
58  /// This operation traits class defines all computational operations and
59  /// constants which are used in the Dijkstra algorithm for widest path
60  /// computation.
61  ///
62  /// \see DijkstraDefaultOperationTraits
63  template <typename Value>
64  struct DijkstraWidestPathOperationTraits {
65    /// \brief Gives back the maximum value of the type.
66    static Value zero() {
67      return std::numeric_limits<Value>::max();
68    }
69    /// \brief Gives back the minimum of the given two elements.
70    static Value plus(const Value& left, const Value& right) {
71      return std::min(left, right);
72    }
73    /// \brief Gives back true only if the first value is less than the second.
74    static bool less(const Value& left, const Value& right) {
75      return left < right;
76    }
77  };
78
79  ///Default traits class of Dijkstra class.
80
81  ///Default traits class of Dijkstra class.
82  ///\tparam GR The type of the digraph.
83  ///\tparam LM The type of the length map.
84  template<class GR, class LM>
85  struct DijkstraDefaultTraits
86  {
87    ///The type of the digraph the algorithm runs on.
88    typedef GR Digraph;
89
90    ///The type of the map that stores the arc lengths.
91
92    ///The type of the map that stores the arc lengths.
93    ///It must meet the \ref concepts::ReadMap "ReadMap" concept.
94    typedef LM LengthMap;
95    ///The type of the length of the arcs.
96    typedef typename LM::Value Value;
97
98    /// Operation traits for Dijkstra algorithm.
99
100    /// This class defines the operations that are used in the algorithm.
101    /// \see DijkstraDefaultOperationTraits
102    typedef DijkstraDefaultOperationTraits<Value> OperationTraits;
103
104    /// The cross reference type used by the heap.
105
106    /// The cross reference type used by the heap.
107    /// Usually it is \c Digraph::NodeMap<int>.
108    typedef typename Digraph::template NodeMap<int> HeapCrossRef;
109    ///Instantiates a \ref HeapCrossRef.
110
111    ///This function instantiates a \ref HeapCrossRef.
112    /// \param g is the digraph, to which we would like to define the
113    /// \ref HeapCrossRef.
114    static HeapCrossRef *createHeapCrossRef(const Digraph &g)
115    {
116      return new HeapCrossRef(g);
117    }
118
119    ///The heap type used by the Dijkstra algorithm.
120
121    ///The heap type used by the Dijkstra algorithm.
122    ///
123    ///\sa BinHeap
124    ///\sa Dijkstra
125    typedef BinHeap<typename LM::Value, HeapCrossRef, std::less<Value> > Heap;
126    ///Instantiates a \ref Heap.
127
128    ///This function instantiates a \ref Heap.
129    static Heap *createHeap(HeapCrossRef& r)
130    {
131      return new Heap(r);
132    }
133
134    ///\brief The type of the map that stores the predecessor
135    ///arcs of the shortest paths.
136    ///
137    ///The type of the map that stores the predecessor
138    ///arcs of the shortest paths.
139    ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
140    typedef typename Digraph::template NodeMap<typename Digraph::Arc> PredMap;
141    ///Instantiates a \ref PredMap.
142
143    ///This function instantiates a \ref PredMap.
144    ///\param g is the digraph, to which we would like to define the
145    ///\ref PredMap.
146    ///\todo The digraph alone may be insufficient for the initialization
147    static PredMap *createPredMap(const Digraph &g)
148    {
149      return new PredMap(g);
150    }
151
152    ///The type of the map that indicates which nodes are processed.
153
154    ///The type of the map that indicates which nodes are processed.
155    ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
156    ///By default it is a NullMap.
157    ///\todo If it is set to a real map,
158    ///Dijkstra::processed() should read this.
159    typedef NullMap<typename Digraph::Node,bool> ProcessedMap;
160    ///Instantiates a \ref ProcessedMap.
161
162    ///This function instantiates a \ref ProcessedMap.
163    ///\param g is the digraph, to which
164    ///we would like to define the \ref ProcessedMap
165#ifdef DOXYGEN
166    static ProcessedMap *createProcessedMap(const Digraph &g)
167#else
168    static ProcessedMap *createProcessedMap(const Digraph &)
169#endif
170    {
171      return new ProcessedMap();
172    }
173
174    ///The type of the map that stores the distances of the nodes.
175
176    ///The type of the map that stores the distances of the nodes.
177    ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
178    typedef typename Digraph::template NodeMap<typename LM::Value> DistMap;
179    ///Instantiates a \ref DistMap.
180
181    ///This function instantiates a \ref DistMap.
182    ///\param g is the digraph, to which we would like to define
183    ///the \ref DistMap
184    static DistMap *createDistMap(const Digraph &g)
185    {
186      return new DistMap(g);
187    }
188  };
189
190  ///%Dijkstra algorithm class.
191
192  /// \ingroup shortest_path
193  ///This class provides an efficient implementation of the %Dijkstra algorithm.
194  ///
195  ///The arc lengths are passed to the algorithm using a
196  ///\ref concepts::ReadMap "ReadMap",
197  ///so it is easy to change it to any kind of length.
198  ///The type of the length is determined by the
199  ///\ref concepts::ReadMap::Value "Value" of the length map.
200  ///It is also possible to change the underlying priority heap.
201  ///
202  ///There is also a \ref dijkstra() "function type interface" for the
203  ///%Dijkstra algorithm, which is convenient in the simplier cases and
204  ///it can be used easier.
205  ///
206  ///\tparam GR The type of the digraph the algorithm runs on.
207  ///The default value is \ref ListDigraph.
208  ///The value of GR is not used directly by \ref Dijkstra, it is only
209  ///passed to \ref DijkstraDefaultTraits.
210  ///\tparam LM A readable arc map that determines the lengths of the
211  ///arcs. It is read once for each arc, so the map may involve in
212  ///relatively time consuming process to compute the arc lengths if
213  ///it is necessary. The default map type is \ref
214  ///concepts::Digraph::ArcMap "Digraph::ArcMap<int>".
215  ///The value of LM is not used directly by \ref Dijkstra, it is only
216  ///passed to \ref DijkstraDefaultTraits.
217  ///\tparam TR Traits class to set various data types used by the algorithm.
218  ///The default traits class is \ref DijkstraDefaultTraits
219  ///"DijkstraDefaultTraits<GR,LM>". See \ref DijkstraDefaultTraits
220  ///for the documentation of a Dijkstra traits class.
221#ifdef DOXYGEN
222  template <typename GR, typename LM, typename TR>
223#else
224  template <typename GR=ListDigraph,
225            typename LM=typename GR::template ArcMap<int>,
226            typename TR=DijkstraDefaultTraits<GR,LM> >
227#endif
228  class Dijkstra {
229  public:
230    ///\ref Exception for uninitialized parameters.
231
232    ///This error represents problems in the initialization of the
233    ///parameters of the algorithm.
234    class UninitializedParameter : public lemon::UninitializedParameter {
235    public:
236      virtual const char* what() const throw() {
237        return "lemon::Dijkstra::UninitializedParameter";
238      }
239    };
240
241    ///The type of the digraph the algorithm runs on.
242    typedef typename TR::Digraph Digraph;
243
244    ///The type of the length of the arcs.
245    typedef typename TR::LengthMap::Value Value;
246    ///The type of the map that stores the arc lengths.
247    typedef typename TR::LengthMap LengthMap;
248    ///\brief The type of the map that stores the predecessor arcs of the
249    ///shortest paths.
250    typedef typename TR::PredMap PredMap;
251    ///The type of the map that stores the distances of the nodes.
252    typedef typename TR::DistMap DistMap;
253    ///The type of the map that indicates which nodes are processed.
254    typedef typename TR::ProcessedMap ProcessedMap;
255    ///The type of the paths.
256    typedef PredMapPath<Digraph, PredMap> Path;
257    ///The cross reference type used for the current heap.
258    typedef typename TR::HeapCrossRef HeapCrossRef;
259    ///The heap type used by the algorithm.
260    typedef typename TR::Heap Heap;
261    ///The operation traits class.
262    typedef typename TR::OperationTraits OperationTraits;
263
264    ///The traits class.
265    typedef TR Traits;
266
267  private:
268
269    typedef typename Digraph::Node Node;
270    typedef typename Digraph::NodeIt NodeIt;
271    typedef typename Digraph::Arc Arc;
272    typedef typename Digraph::OutArcIt OutArcIt;
273
274    //Pointer to the underlying digraph.
275    const Digraph *G;
276    //Pointer to the length map.
277    const LengthMap *length;
278    //Pointer to the map of predecessors arcs.
279    PredMap *_pred;
280    //Indicates if _pred is locally allocated (true) or not.
281    bool local_pred;
282    //Pointer to the map of distances.
283    DistMap *_dist;
284    //Indicates if _dist is locally allocated (true) or not.
285    bool local_dist;
286    //Pointer to the map of processed status of the nodes.
287    ProcessedMap *_processed;
288    //Indicates if _processed is locally allocated (true) or not.
289    bool local_processed;
290    //Pointer to the heap cross references.
291    HeapCrossRef *_heap_cross_ref;
292    //Indicates if _heap_cross_ref is locally allocated (true) or not.
293    bool local_heap_cross_ref;
294    //Pointer to the heap.
295    Heap *_heap;
296    //Indicates if _heap is locally allocated (true) or not.
297    bool local_heap;
298
299    ///Creates the maps if necessary.
300    ///\todo Better memory allocation (instead of new).
301    void create_maps()
302    {
303      if(!_pred) {
304        local_pred = true;
305        _pred = Traits::createPredMap(*G);
306      }
307      if(!_dist) {
308        local_dist = true;
309        _dist = Traits::createDistMap(*G);
310      }
311      if(!_processed) {
312        local_processed = true;
313        _processed = Traits::createProcessedMap(*G);
314      }
315      if (!_heap_cross_ref) {
316        local_heap_cross_ref = true;
317        _heap_cross_ref = Traits::createHeapCrossRef(*G);
318      }
319      if (!_heap) {
320        local_heap = true;
321        _heap = Traits::createHeap(*_heap_cross_ref);
322      }
323    }
324
325  public:
326
327    typedef Dijkstra Create;
328
329    ///\name Named template parameters
330
331    ///@{
332
333    template <class T>
334    struct DefPredMapTraits : public Traits {
335      typedef T PredMap;
336      static PredMap *createPredMap(const Digraph &)
337      {
338        throw UninitializedParameter();
339      }
340    };
341    ///\brief \ref named-templ-param "Named parameter" for setting
342    ///\ref PredMap type.
343    ///
344    ///\ref named-templ-param "Named parameter" for setting
345    ///\ref PredMap type.
346    template <class T>
347    struct DefPredMap
348      : public Dijkstra< Digraph, LengthMap, DefPredMapTraits<T> > {
349      typedef Dijkstra< Digraph, LengthMap, DefPredMapTraits<T> > Create;
350    };
351
352    template <class T>
353    struct DefDistMapTraits : public Traits {
354      typedef T DistMap;
355      static DistMap *createDistMap(const Digraph &)
356      {
357        throw UninitializedParameter();
358      }
359    };
360    ///\brief \ref named-templ-param "Named parameter" for setting
361    ///\ref DistMap type.
362    ///
363    ///\ref named-templ-param "Named parameter" for setting
364    ///\ref DistMap type.
365    template <class T>
366    struct DefDistMap
367      : public Dijkstra< Digraph, LengthMap, DefDistMapTraits<T> > {
368      typedef Dijkstra< Digraph, LengthMap, DefDistMapTraits<T> > Create;
369    };
370
371    template <class T>
372    struct DefProcessedMapTraits : public Traits {
373      typedef T ProcessedMap;
374      static ProcessedMap *createProcessedMap(const Digraph &)
375      {
376        throw UninitializedParameter();
377      }
378    };
379    ///\brief \ref named-templ-param "Named parameter" for setting
380    ///\ref ProcessedMap type.
381    ///
382    ///\ref named-templ-param "Named parameter" for setting
383    ///\ref ProcessedMap type.
384    template <class T>
385    struct DefProcessedMap
386      : public Dijkstra< Digraph, LengthMap, DefProcessedMapTraits<T> > {
387      typedef Dijkstra< Digraph, LengthMap, DefProcessedMapTraits<T> > Create;
388    };
389
390    struct DefDigraphProcessedMapTraits : public Traits {
391      typedef typename Digraph::template NodeMap<bool> ProcessedMap;
392      static ProcessedMap *createProcessedMap(const Digraph &g)
393      {
394        return new ProcessedMap(g);
395      }
396    };
397    ///\brief \ref named-templ-param "Named parameter" for setting
398    ///\ref ProcessedMap type to be <tt>Digraph::NodeMap<bool></tt>.
399    ///
400    ///\ref named-templ-param "Named parameter" for setting
401    ///\ref ProcessedMap type to be <tt>Digraph::NodeMap<bool></tt>.
402    ///If you don't set it explicitly, it will be automatically allocated.
403    template <class T>
404    struct DefProcessedMapToBeDefaultMap
405      : public Dijkstra< Digraph, LengthMap, DefDigraphProcessedMapTraits> {
406      typedef Dijkstra< Digraph, LengthMap, DefDigraphProcessedMapTraits>
407      Create;
408    };
409
410    template <class H, class CR>
411    struct DefHeapTraits : public Traits {
412      typedef CR HeapCrossRef;
413      typedef H Heap;
414      static HeapCrossRef *createHeapCrossRef(const Digraph &) {
415        throw UninitializedParameter();
416      }
417      static Heap *createHeap(HeapCrossRef &)
418      {
419        throw UninitializedParameter();
420      }
421    };
422    ///\brief \ref named-templ-param "Named parameter" for setting
423    ///heap and cross reference type
424    ///
425    ///\ref named-templ-param "Named parameter" for setting heap and cross
426    ///reference type.
427    template <class H, class CR = typename Digraph::template NodeMap<int> >
428    struct DefHeap
429      : public Dijkstra< Digraph, LengthMap, DefHeapTraits<H, CR> > {
430      typedef Dijkstra< Digraph, LengthMap, DefHeapTraits<H, CR> > Create;
431    };
432
433    template <class H, class CR>
434    struct DefStandardHeapTraits : public Traits {
435      typedef CR HeapCrossRef;
436      typedef H Heap;
437      static HeapCrossRef *createHeapCrossRef(const Digraph &G) {
438        return new HeapCrossRef(G);
439      }
440      static Heap *createHeap(HeapCrossRef &R)
441      {
442        return new Heap(R);
443      }
444    };
445    ///\brief \ref named-templ-param "Named parameter" for setting
446    ///heap and cross reference type with automatic allocation
447    ///
448    ///\ref named-templ-param "Named parameter" for setting heap and cross
449    ///reference type. It can allocate the heap and the cross reference
450    ///object if the cross reference's constructor waits for the digraph as
451    ///parameter and the heap's constructor waits for the cross reference.
452    template <class H, class CR = typename Digraph::template NodeMap<int> >
453    struct DefStandardHeap
454      : public Dijkstra< Digraph, LengthMap, DefStandardHeapTraits<H, CR> > {
455      typedef Dijkstra< Digraph, LengthMap, DefStandardHeapTraits<H, CR> >
456      Create;
457    };
458
459    template <class T>
460    struct DefOperationTraitsTraits : public Traits {
461      typedef T OperationTraits;
462    };
463
464    /// \brief \ref named-templ-param "Named parameter" for setting
465    ///\ref OperationTraits type
466    ///
467    ///\ref named-templ-param "Named parameter" for setting
468    ///\ref OperationTraits type.
469    template <class T>
470    struct DefOperationTraits
471      : public Dijkstra<Digraph, LengthMap, DefOperationTraitsTraits<T> > {
472      typedef Dijkstra<Digraph, LengthMap, DefOperationTraitsTraits<T> >
473      Create;
474    };
475
476    ///@}
477
478  protected:
479
480    Dijkstra() {}
481
482  public:
483
484    ///Constructor.
485
486    ///Constructor.
487    ///\param _g The digraph the algorithm runs on.
488    ///\param _length The length map used by the algorithm.
489    Dijkstra(const Digraph& _g, const LengthMap& _length) :
490      G(&_g), length(&_length),
491      _pred(NULL), local_pred(false),
492      _dist(NULL), local_dist(false),
493      _processed(NULL), local_processed(false),
494      _heap_cross_ref(NULL), local_heap_cross_ref(false),
495      _heap(NULL), local_heap(false)
496    { }
497
498    ///Destructor.
499    ~Dijkstra()
500    {
501      if(local_pred) delete _pred;
502      if(local_dist) delete _dist;
503      if(local_processed) delete _processed;
504      if(local_heap_cross_ref) delete _heap_cross_ref;
505      if(local_heap) delete _heap;
506    }
507
508    ///Sets the length map.
509
510    ///Sets the length map.
511    ///\return <tt> (*this) </tt>
512    Dijkstra &lengthMap(const LengthMap &m)
513    {
514      length = &m;
515      return *this;
516    }
517
518    ///Sets the map that stores the predecessor arcs.
519
520    ///Sets the map that stores the predecessor arcs.
521    ///If you don't use this function before calling \ref run(),
522    ///it will allocate one. The destructor deallocates this
523    ///automatically allocated map, of course.
524    ///\return <tt> (*this) </tt>
525    Dijkstra &predMap(PredMap &m)
526    {
527      if(local_pred) {
528        delete _pred;
529        local_pred=false;
530      }
531      _pred = &m;
532      return *this;
533    }
534
535    ///Sets the map that indicates which nodes are processed.
536
537    ///Sets the map that indicates which nodes are processed.
538    ///If you don't use this function before calling \ref run(),
539    ///it will allocate one. The destructor deallocates this
540    ///automatically allocated map, of course.
541    ///\return <tt> (*this) </tt>
542    Dijkstra &processedMap(ProcessedMap &m)
543    {
544      if(local_processed) {
545        delete _processed;
546        local_processed=false;
547      }
548      _processed = &m;
549      return *this;
550    }
551
552    ///Sets the map that stores the distances of the nodes.
553
554    ///Sets the map that stores the distances of the nodes calculated by the
555    ///algorithm.
556    ///If you don't use this function before calling \ref run(),
557    ///it will allocate one. The destructor deallocates this
558    ///automatically allocated map, of course.
559    ///\return <tt> (*this) </tt>
560    Dijkstra &distMap(DistMap &m)
561    {
562      if(local_dist) {
563        delete _dist;
564        local_dist=false;
565      }
566      _dist = &m;
567      return *this;
568    }
569
570    ///Sets the heap and the cross reference used by algorithm.
571
572    ///Sets the heap and the cross reference used by algorithm.
573    ///If you don't use this function before calling \ref run(),
574    ///it will allocate one. The destructor deallocates this
575    ///automatically allocated heap and cross reference, of course.
576    ///\return <tt> (*this) </tt>
577    Dijkstra &heap(Heap& hp, HeapCrossRef &cr)
578    {
579      if(local_heap_cross_ref) {
580        delete _heap_cross_ref;
581        local_heap_cross_ref=false;
582      }
583      _heap_cross_ref = &cr;
584      if(local_heap) {
585        delete _heap;
586        local_heap=false;
587      }
588      _heap = &hp;
589      return *this;
590    }
591
592  private:
593
594    void finalizeNodeData(Node v,Value dst)
595    {
596      _processed->set(v,true);
597      _dist->set(v, dst);
598    }
599
600  public:
601
602    ///\name Execution control
603    ///The simplest way to execute the algorithm is to use one of the
604    ///member functions called \ref lemon::Dijkstra::run() "run()".
605    ///\n
606    ///If you need more control on the execution, first you must call
607    ///\ref lemon::Dijkstra::init() "init()", then you can add several
608    ///source nodes with \ref lemon::Dijkstra::addSource() "addSource()".
609    ///Finally \ref lemon::Dijkstra::start() "start()" will perform the
610    ///actual path computation.
611
612    ///@{
613
614    ///Initializes the internal data structures.
615
616    ///Initializes the internal data structures.
617    ///
618    void init()
619    {
620      create_maps();
621      _heap->clear();
622      for ( NodeIt u(*G) ; u!=INVALID ; ++u ) {
623        _pred->set(u,INVALID);
624        _processed->set(u,false);
625        _heap_cross_ref->set(u,Heap::PRE_HEAP);
626      }
627    }
628
629    ///Adds a new source node.
630
631    ///Adds a new source node to the priority heap.
632    ///The optional second parameter is the initial distance of the node.
633    ///
634    ///The function checks if the node has already been added to the heap and
635    ///it is pushed to the heap only if either it was not in the heap
636    ///or the shortest path found till then is shorter than \c dst.
637    void addSource(Node s,Value dst=OperationTraits::zero())
638    {
639      if(_heap->state(s) != Heap::IN_HEAP) {
640        _heap->push(s,dst);
641      } else if(OperationTraits::less((*_heap)[s], dst)) {
642        _heap->set(s,dst);
643        _pred->set(s,INVALID);
644      }
645    }
646
647    ///Processes the next node in the priority heap
648
649    ///Processes the next node in the priority heap.
650    ///
651    ///\return The processed node.
652    ///
653    ///\warning The priority heap must not be empty.
654    Node processNextNode()
655    {
656      Node v=_heap->top();
657      Value oldvalue=_heap->prio();
658      _heap->pop();
659      finalizeNodeData(v,oldvalue);
660
661      for(OutArcIt e(*G,v); e!=INVALID; ++e) {
662        Node w=G->target(e);
663        switch(_heap->state(w)) {
664        case Heap::PRE_HEAP:
665          _heap->push(w,OperationTraits::plus(oldvalue, (*length)[e]));
666          _pred->set(w,e);
667          break;
668        case Heap::IN_HEAP:
669          {
670            Value newvalue = OperationTraits::plus(oldvalue, (*length)[e]);
671            if ( OperationTraits::less(newvalue, (*_heap)[w]) ) {
672              _heap->decrease(w, newvalue);
673              _pred->set(w,e);
674            }
675          }
676          break;
677        case Heap::POST_HEAP:
678          break;
679        }
680      }
681      return v;
682    }
683
684    ///The next node to be processed.
685
686    ///Returns the next node to be processed or \c INVALID if the
687    ///priority heap is empty.
688    Node nextNode() const
689    {
690      return !_heap->empty()?_heap->top():INVALID;
691    }
692
693    ///\brief Returns \c false if there are nodes
694    ///to be processed.
695    ///
696    ///Returns \c false if there are nodes
697    ///to be processed in the priority heap.
698    bool emptyQueue() const { return _heap->empty(); }
699
700    ///Returns the number of the nodes to be processed in the priority heap
701
702    ///Returns the number of the nodes to be processed in the priority heap.
703    ///
704    int queueSize() const { return _heap->size(); }
705
706    ///Executes the algorithm.
707
708    ///Executes the algorithm.
709    ///
710    ///This method runs the %Dijkstra algorithm from the root node(s)
711    ///in order to compute the shortest path to each node.
712    ///
713    ///The algorithm computes
714    ///- the shortest path tree (forest),
715    ///- the distance of each node from the root(s).
716    ///
717    ///\pre init() must be called and at least one root node should be
718    ///added with addSource() before using this function.
719    ///
720    ///\note <tt>d.start()</tt> is just a shortcut of the following code.
721    ///\code
722    ///  while ( !d.emptyQueue() ) {
723    ///    d.processNextNode();
724    ///  }
725    ///\endcode
726    void start()
727    {
728      while ( !emptyQueue() ) processNextNode();
729    }
730
731    ///Executes the algorithm until the given target node is reached.
732
733    ///Executes the algorithm until the given target node is reached.
734    ///
735    ///This method runs the %Dijkstra algorithm from the root node(s)
736    ///in order to compute the shortest path to \c dest.
737    ///
738    ///The algorithm computes
739    ///- the shortest path to \c dest,
740    ///- the distance of \c dest from the root(s).
741    ///
742    ///\pre init() must be called and at least one root node should be
743    ///added with addSource() before using this function.
744    void start(Node dest)
745    {
746      while ( !_heap->empty() && _heap->top()!=dest ) processNextNode();
747      if ( !_heap->empty() ) finalizeNodeData(_heap->top(),_heap->prio());
748    }
749
750    ///Executes the algorithm until a condition is met.
751
752    ///Executes the algorithm until a condition is met.
753    ///
754    ///This method runs the %Dijkstra algorithm from the root node(s) in
755    ///order to compute the shortest path to a node \c v with
756    /// <tt>nm[v]</tt> true, if such a node can be found.
757    ///
758    ///\param nm A \c bool (or convertible) node map. The algorithm
759    ///will stop when it reaches a node \c v with <tt>nm[v]</tt> true.
760    ///
761    ///\return The reached node \c v with <tt>nm[v]</tt> true or
762    ///\c INVALID if no such node was found.
763    ///
764    ///\pre init() must be called and at least one root node should be
765    ///added with addSource() before using this function.
766    template<class NodeBoolMap>
767    Node start(const NodeBoolMap &nm)
768    {
769      while ( !_heap->empty() && !nm[_heap->top()] ) processNextNode();
770      if ( _heap->empty() ) return INVALID;
771      finalizeNodeData(_heap->top(),_heap->prio());
772      return _heap->top();
773    }
774
775    ///Runs the algorithm from the given node.
776
777    ///This method runs the %Dijkstra algorithm from node \c s
778    ///in order to compute the shortest path to each node.
779    ///
780    ///The algorithm computes
781    ///- the shortest path tree,
782    ///- the distance of each node from the root.
783    ///
784    ///\note <tt>d.run(s)</tt> is just a shortcut of the following code.
785    ///\code
786    ///  d.init();
787    ///  d.addSource(s);
788    ///  d.start();
789    ///\endcode
790    void run(Node s) {
791      init();
792      addSource(s);
793      start();
794    }
795
796    ///Finds the shortest path between \c s and \c t.
797
798    ///This method runs the %Dijkstra algorithm from node \c s
799    ///in order to compute the shortest path to \c t.
800    ///
801    ///\return The length of the shortest <tt>s</tt>--<tt>t</tt> path,
802    ///if \c t is reachable form \c s, \c 0 otherwise.
803    ///
804    ///\note Apart from the return value, <tt>d.run(s,t)</tt> is just a
805    ///shortcut of the following code.
806    ///\code
807    ///  d.init();
808    ///  d.addSource(s);
809    ///  d.start(t);
810    ///\endcode
811    Value run(Node s,Node t) {
812      init();
813      addSource(s);
814      start(t);
815      return (*_pred)[t]==INVALID?OperationTraits::zero():(*_dist)[t];
816    }
817
818    ///@}
819
820    ///\name Query Functions
821    ///The result of the %Dijkstra algorithm can be obtained using these
822    ///functions.\n
823    ///Either \ref lemon::Dijkstra::run() "run()" or
824    ///\ref lemon::Dijkstra::start() "start()" must be called before
825    ///using them.
826
827    ///@{
828
829    ///The shortest path to a node.
830
831    ///Returns the shortest path to a node.
832    ///
833    ///\warning \c t should be reachable from the root(s).
834    ///
835    ///\pre Either \ref run() or \ref start() must be called before
836    ///using this function.
837    Path path(Node t) const { return Path(*G, *_pred, t); }
838
839    ///The distance of a node from the root(s).
840
841    ///Returns the distance of a node from the root(s).
842    ///
843    ///\warning If node \c v is not reachable from the root(s), then
844    ///the return value of this function is undefined.
845    ///
846    ///\pre Either \ref run() or \ref start() must be called before
847    ///using this function.
848    Value dist(Node v) const { return (*_dist)[v]; }
849
850    ///Returns the 'previous arc' of the shortest path tree for a node.
851
852    ///This function returns the 'previous arc' of the shortest path
853    ///tree for the node \c v, i.e. it returns the last arc of a
854    ///shortest path from the root(s) to \c v. It is \c INVALID if \c v
855    ///is not reachable from the root(s) or if \c v is a root.
856    ///
857    ///The shortest path tree used here is equal to the shortest path
858    ///tree used in \ref predNode().
859    ///
860    ///\pre Either \ref run() or \ref start() must be called before
861    ///using this function.
862    Arc predArc(Node v) const { return (*_pred)[v]; }
863
864    ///Returns the 'previous node' of the shortest path tree for a node.
865
866    ///This function returns the 'previous node' of the shortest path
867    ///tree for the node \c v, i.e. it returns the last but one node
868    ///from a shortest path from the root(s) to \c v. It is \c INVALID
869    ///if \c v is not reachable from the root(s) or if \c v is a root.
870    ///
871    ///The shortest path tree used here is equal to the shortest path
872    ///tree used in \ref predArc().
873    ///
874    ///\pre Either \ref run() or \ref start() must be called before
875    ///using this function.
876    Node predNode(Node v) const { return (*_pred)[v]==INVALID ? INVALID:
877                                  G->source((*_pred)[v]); }
878
879    ///\brief Returns a const reference to the node map that stores the
880    ///distances of the nodes.
881    ///
882    ///Returns a const reference to the node map that stores the distances
883    ///of the nodes calculated by the algorithm.
884    ///
885    ///\pre Either \ref run() or \ref init()
886    ///must be called before using this function.
887    const DistMap &distMap() const { return *_dist;}
888
889    ///\brief Returns a const reference to the node map that stores the
890    ///predecessor arcs.
891    ///
892    ///Returns a const reference to the node map that stores the predecessor
893    ///arcs, which form the shortest path tree.
894    ///
895    ///\pre Either \ref run() or \ref init()
896    ///must be called before using this function.
897    const PredMap &predMap() const { return *_pred;}
898
899    ///Checks if a node is reachable from the root(s).
900
901    ///Returns \c true if \c v is reachable from the root(s).
902    ///\pre Either \ref run() or \ref start()
903    ///must be called before using this function.
904    bool reached(Node v) const { return (*_heap_cross_ref)[v] !=
905                                        Heap::PRE_HEAP; }
906
907    ///Checks if a node is processed.
908
909    ///Returns \c true if \c v is processed, i.e. the shortest
910    ///path to \c v has already found.
911    ///\pre Either \ref run() or \ref start()
912    ///must be called before using this function.
913    bool processed(Node v) const { return (*_heap_cross_ref)[v] ==
914                                          Heap::POST_HEAP; }
915
916    ///The current distance of a node from the root(s).
917
918    ///Returns the current distance of a node from the root(s).
919    ///It may be decreased in the following processes.
920    ///\pre \c v should be reached but not processed.
921    Value currentDist(Node v) const { return (*_heap)[v]; }
922
923    ///@}
924  };
925
926
927  ///Default traits class of dijkstra() function.
928
929  ///Default traits class of dijkstra() function.
930  ///\tparam GR The type of the digraph.
931  ///\tparam LM The type of the length map.
932  template<class GR, class LM>
933  struct DijkstraWizardDefaultTraits
934  {
935    ///The type of the digraph the algorithm runs on.
936    typedef GR Digraph;
937    ///The type of the map that stores the arc lengths.
938
939    ///The type of the map that stores the arc lengths.
940    ///It must meet the \ref concepts::ReadMap "ReadMap" concept.
941    typedef LM LengthMap;
942    ///The type of the length of the arcs.
943    typedef typename LM::Value Value;
944
945    /// Operation traits for Dijkstra algorithm.
946
947    /// This class defines the operations that are used in the algorithm.
948    /// \see DijkstraDefaultOperationTraits
949    typedef DijkstraDefaultOperationTraits<Value> OperationTraits;
950
951    /// The cross reference type used by the heap.
952
953    /// The cross reference type used by the heap.
954    /// Usually it is \c Digraph::NodeMap<int>.
955    typedef typename Digraph::template NodeMap<int> HeapCrossRef;
956    ///Instantiates a \ref HeapCrossRef.
957
958    ///This function instantiates a \ref HeapCrossRef.
959    /// \param g is the digraph, to which we would like to define the
960    /// HeapCrossRef.
961    /// \todo The digraph alone may be insufficient for the initialization
962    static HeapCrossRef *createHeapCrossRef(const Digraph &g)
963    {
964      return new HeapCrossRef(g);
965    }
966
967    ///The heap type used by the Dijkstra algorithm.
968
969    ///The heap type used by the Dijkstra algorithm.
970    ///
971    ///\sa BinHeap
972    ///\sa Dijkstra
973    typedef BinHeap<Value, typename Digraph::template NodeMap<int>,
974                    std::less<Value> > Heap;
975
976    ///Instantiates a \ref Heap.
977
978    ///This function instantiates a \ref Heap.
979    /// \param r is the HeapCrossRef which is used.
980    static Heap *createHeap(HeapCrossRef& r)
981    {
982      return new Heap(r);
983    }
984
985    ///\brief The type of the map that stores the predecessor
986    ///arcs of the shortest paths.
987    ///
988    ///The type of the map that stores the predecessor
989    ///arcs of the shortest paths.
990    ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
991    typedef NullMap <typename Digraph::Node,typename Digraph::Arc> PredMap;
992    ///Instantiates a \ref PredMap.
993
994    ///This function instantiates a \ref PredMap.
995    ///\param g is the digraph, to which we would like to define the
996    ///\ref PredMap.
997    ///\todo The digraph alone may be insufficient to initialize
998#ifdef DOXYGEN
999    static PredMap *createPredMap(const Digraph &g)
1000#else
1001    static PredMap *createPredMap(const Digraph &)
1002#endif
1003    {
1004      return new PredMap();
1005    }
1006
1007    ///The type of the map that indicates which nodes are processed.
1008
1009    ///The type of the map that indicates which nodes are processed.
1010    ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
1011    ///By default it is a NullMap.
1012    ///\todo If it is set to a real map,
1013    ///Dijkstra::processed() should read this.
1014    ///\todo named parameter to set this type, function to read and write.
1015    typedef NullMap<typename Digraph::Node,bool> ProcessedMap;
1016    ///Instantiates a \ref ProcessedMap.
1017
1018    ///This function instantiates a \ref ProcessedMap.
1019    ///\param g is the digraph, to which
1020    ///we would like to define the \ref ProcessedMap.
1021#ifdef DOXYGEN
1022    static ProcessedMap *createProcessedMap(const Digraph &g)
1023#else
1024    static ProcessedMap *createProcessedMap(const Digraph &)
1025#endif
1026    {
1027      return new ProcessedMap();
1028    }
1029
1030    ///The type of the map that stores the distances of the nodes.
1031
1032    ///The type of the map that stores the distances of the nodes.
1033    ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
1034    typedef NullMap<typename Digraph::Node,Value> DistMap;
1035    ///Instantiates a \ref DistMap.
1036
1037    ///This function instantiates a \ref DistMap.
1038    ///\param g is the digraph, to which we would like to define
1039    ///the \ref DistMap
1040#ifdef DOXYGEN
1041    static DistMap *createDistMap(const Digraph &g)
1042#else
1043    static DistMap *createDistMap(const Digraph &)
1044#endif
1045    {
1046      return new DistMap();
1047    }
1048  };
1049
1050  /// Default traits class used by \ref DijkstraWizard
1051
1052  /// To make it easier to use Dijkstra algorithm
1053  /// we have created a wizard class.
1054  /// This \ref DijkstraWizard class needs default traits,
1055  /// as well as the \ref Dijkstra class.
1056  /// The \ref DijkstraWizardBase is a class to be the default traits of the
1057  /// \ref DijkstraWizard class.
1058  /// \todo More named parameters are required...
1059  template<class GR,class LM>
1060  class DijkstraWizardBase : public DijkstraWizardDefaultTraits<GR,LM>
1061  {
1062    typedef DijkstraWizardDefaultTraits<GR,LM> Base;
1063  protected:
1064    //The type of the nodes in the digraph.
1065    typedef typename Base::Digraph::Node Node;
1066
1067    //Pointer to the digraph the algorithm runs on.
1068    void *_g;
1069    //Pointer to the length map
1070    void *_length;
1071    //Pointer to the map of predecessors arcs.
1072    void *_pred;
1073    //Pointer to the map of distances.
1074    void *_dist;
1075    //Pointer to the source node.
1076    Node _source;
1077
1078  public:
1079    /// Constructor.
1080
1081    /// This constructor does not require parameters, therefore it initiates
1082    /// all of the attributes to default values (0, INVALID).
1083    DijkstraWizardBase() : _g(0), _length(0), _pred(0),
1084                           _dist(0), _source(INVALID) {}
1085
1086    /// Constructor.
1087
1088    /// This constructor requires some parameters,
1089    /// listed in the parameters list.
1090    /// Others are initiated to 0.
1091    /// \param g The digraph the algorithm runs on.
1092    /// \param l The length map.
1093    /// \param s The source node.
1094    DijkstraWizardBase(const GR &g,const LM &l, Node s=INVALID) :
1095      _g(reinterpret_cast<void*>(const_cast<GR*>(&g))),
1096      _length(reinterpret_cast<void*>(const_cast<LM*>(&l))),
1097      _pred(0), _dist(0), _source(s) {}
1098
1099  };
1100
1101  /// Auxiliary class for the function type interface of Dijkstra algorithm.
1102
1103  /// This auxiliary class is created to implement the function type
1104  /// interface of \ref Dijkstra algorithm. It uses the functions and features
1105  /// of the plain \ref Dijkstra, but it is much simpler to use it.
1106  /// It should only be used through the \ref dijkstra() function, which makes
1107  /// it easier to use the algorithm.
1108  ///
1109  /// Simplicity means that the way to change the types defined
1110  /// in the traits class is based on functions that returns the new class
1111  /// and not on templatable built-in classes.
1112  /// When using the plain \ref Dijkstra
1113  /// the new class with the modified type comes from
1114  /// the original class by using the ::
1115  /// operator. In the case of \ref DijkstraWizard only
1116  /// a function have to be called, and it will
1117  /// return the needed class.
1118  ///
1119  /// It does not have own \ref run() method. When its \ref run() method
1120  /// is called, it initiates a plain \ref Dijkstra object, and calls the
1121  /// \ref Dijkstra::run() method of it.
1122  template<class TR>
1123  class DijkstraWizard : public TR
1124  {
1125    typedef TR Base;
1126
1127    ///The type of the digraph the algorithm runs on.
1128    typedef typename TR::Digraph Digraph;
1129
1130    typedef typename Digraph::Node Node;
1131    typedef typename Digraph::NodeIt NodeIt;
1132    typedef typename Digraph::Arc Arc;
1133    typedef typename Digraph::OutArcIt OutArcIt;
1134
1135    ///The type of the map that stores the arc lengths.
1136    typedef typename TR::LengthMap LengthMap;
1137    ///The type of the length of the arcs.
1138    typedef typename LengthMap::Value Value;
1139    ///\brief The type of the map that stores the predecessor
1140    ///arcs of the shortest paths.
1141    typedef typename TR::PredMap PredMap;
1142    ///The type of the map that stores the distances of the nodes.
1143    typedef typename TR::DistMap DistMap;
1144    ///The type of the map that indicates which nodes are processed.
1145    typedef typename TR::ProcessedMap ProcessedMap;
1146    ///The heap type used by the dijkstra algorithm.
1147    typedef typename TR::Heap Heap;
1148
1149  public:
1150
1151    /// Constructor.
1152    DijkstraWizard() : TR() {}
1153
1154    /// Constructor that requires parameters.
1155
1156    /// Constructor that requires parameters.
1157    /// These parameters will be the default values for the traits class.
1158    DijkstraWizard(const Digraph &g,const LengthMap &l, Node s=INVALID) :
1159      TR(g,l,s) {}
1160
1161    ///Copy constructor
1162    DijkstraWizard(const TR &b) : TR(b) {}
1163
1164    ~DijkstraWizard() {}
1165
1166    ///Runs Dijkstra algorithm from a source node.
1167
1168    ///Runs Dijkstra algorithm from a source node.
1169    ///The node can be given with the \ref source() function.
1170    void run()
1171    {
1172      if(Base::_source==INVALID) throw UninitializedParameter();
1173      Dijkstra<Digraph,LengthMap,TR>
1174        dij(*reinterpret_cast<const Digraph*>(Base::_g),
1175            *reinterpret_cast<const LengthMap*>(Base::_length));
1176      if(Base::_pred) dij.predMap(*reinterpret_cast<PredMap*>(Base::_pred));
1177      if(Base::_dist) dij.distMap(*reinterpret_cast<DistMap*>(Base::_dist));
1178      dij.run(Base::_source);
1179    }
1180
1181    ///Runs Dijkstra algorithm from the given node.
1182
1183    ///Runs Dijkstra algorithm from the given node.
1184    ///\param s is the given source.
1185    void run(Node s)
1186    {
1187      Base::_source=s;
1188      run();
1189    }
1190
1191    /// Sets the source node, from which the Dijkstra algorithm runs.
1192
1193    /// Sets the source node, from which the Dijkstra algorithm runs.
1194    /// \param s is the source node.
1195    DijkstraWizard<TR> &source(Node s)
1196    {
1197      Base::_source=s;
1198      return *this;
1199    }
1200
1201    template<class T>
1202    struct DefPredMapBase : public Base {
1203      typedef T PredMap;
1204      static PredMap *createPredMap(const Digraph &) { return 0; };
1205      DefPredMapBase(const TR &b) : TR(b) {}
1206    };
1207    ///\brief \ref named-templ-param "Named parameter"
1208    ///for setting \ref PredMap object.
1209    ///
1210    ///\ref named-templ-param "Named parameter"
1211    ///for setting \ref PredMap object.
1212    template<class T>
1213    DijkstraWizard<DefPredMapBase<T> > predMap(const T &t)
1214    {
1215      Base::_pred=reinterpret_cast<void*>(const_cast<T*>(&t));
1216      return DijkstraWizard<DefPredMapBase<T> >(*this);
1217    }
1218
1219    template<class T>
1220    struct DefProcessedMapBase : public Base {
1221      typedef T ProcessedMap;
1222      static ProcessedMap *createProcessedMap(const Digraph &) { return 0; };
1223      DefProcessedMapBase(const TR &b) : TR(b) {}
1224    };
1225    ///\brief \ref named-templ-param "Named parameter"
1226    ///for setting \ref ProcessedMap object.
1227    ///
1228    /// \ref named-templ-param "Named parameter"
1229    ///for setting \ref ProcessedMap object.
1230    template<class T>
1231    DijkstraWizard<DefProcessedMapBase<T> > processedMap(const T &t)
1232    {
1233      Base::_processed=reinterpret_cast<void*>(const_cast<T*>(&t));
1234      return DijkstraWizard<DefProcessedMapBase<T> >(*this);
1235    }
1236
1237    template<class T>
1238    struct DefDistMapBase : public Base {
1239      typedef T DistMap;
1240      static DistMap *createDistMap(const Digraph &) { return 0; };
1241      DefDistMapBase(const TR &b) : TR(b) {}
1242    };
1243    ///\brief \ref named-templ-param "Named parameter"
1244    ///for setting \ref DistMap object.
1245    ///
1246    ///\ref named-templ-param "Named parameter"
1247    ///for setting \ref DistMap object.
1248    template<class T>
1249    DijkstraWizard<DefDistMapBase<T> > distMap(const T &t)
1250    {
1251      Base::_dist=reinterpret_cast<void*>(const_cast<T*>(&t));
1252      return DijkstraWizard<DefDistMapBase<T> >(*this);
1253    }
1254
1255  };
1256
1257  ///Function type interface for Dijkstra algorithm.
1258
1259  /// \ingroup shortest_path
1260  ///Function type interface for Dijkstra algorithm.
1261  ///
1262  ///This function also has several
1263  ///\ref named-templ-func-param "named parameters",
1264  ///they are declared as the members of class \ref DijkstraWizard.
1265  ///The following
1266  ///example shows how to use these parameters.
1267  ///\code
1268  ///  dijkstra(g,length,source).predMap(preds).run();
1269  ///\endcode
1270  ///\warning Don't forget to put the \ref DijkstraWizard::run() "run()"
1271  ///to the end of the parameter list.
1272  ///\sa DijkstraWizard
1273  ///\sa Dijkstra
1274  template<class GR, class LM>
1275  DijkstraWizard<DijkstraWizardBase<GR,LM> >
1276  dijkstra(const GR &g,const LM &l,typename GR::Node s=INVALID)
1277  {
1278    return DijkstraWizard<DijkstraWizardBase<GR,LM> >(g,l,s);
1279  }
1280
1281} //END OF NAMESPACE LEMON
1282
1283#endif
Note: See TracBrowser for help on using the repository browser.