RhodeCode

  Dijkstra<Digraph, TimeMap> dijkstra(graph, time);

  dijkstra.run(source, target);

\endcode

We have a length map and a maximum speed map on the arcs of a digraph.

The minimum time to pass the arc can be calculated as the division of

the two maps which can be done implicitly with the \c DivMap template

class. We use the implicit minimum time map as the length map of the

\c Dijkstra algorithm.

*/

/**

@defgroup paths Path Structures

@ingroup datas

\brief %Path structures implemented in LEMON.

This group contains the path structures implemented in LEMON.

LEMON provides flexible data structures to work with paths.

All of them have similar interfaces and they can be copied easily with

assignment operators and copy constructors. This makes it easy and

efficient to have e.g. the Dijkstra algorithm to store its result in

any kind of path structure.

*/

/**

@defgroup auxdat Auxiliary Data Structures

@ingroup datas

\brief Auxiliary data structures implemented in LEMON.

This group contains some data structures implemented in LEMON in

order to make it easier to implement combinatorial algorithms.

*/

/**

 * provided that this copyright notice appears in all copies. For

 * precise terms see the accompanying LICENSE file.

 *

 * This software is provided "AS IS" with no warranty of any kind,

 * express or implied, and with no claim as to its suitability for any

 * purpose.

 *

 */

#ifndef LEMON_BIN_HEAP_H

#define LEMON_BIN_HEAP_H

///\file

///\brief Binary heap implementation.

#include <vector>

#include <utility>

#include <functional>

namespace lemon {

  ///

  /// \brief Binary heap data structure.

  ///

  /// This class implements the \e binary \e heap data structure.

  /// It fully conforms to the \ref concepts::Heap "heap concept".

  ///

  /// \tparam PR Type of the priorities of the items.

  /// \tparam IM A read-writable item map with \c int values, used

  /// internally to handle the cross references.

  /// \tparam CMP A functor class for comparing the priorities.

  /// The default is \c std::less<PR>.

#ifdef DOXYGEN

 * provided that this copyright notice appears in all copies. For

 * precise terms see the accompanying LICENSE file.

 *

 * This software is provided "AS IS" with no warranty of any kind,

 * express or implied, and with no claim as to its suitability for any

 * purpose.

 *

 */

#ifndef LEMON_BUCKET_HEAP_H

#define LEMON_BUCKET_HEAP_H

///\file

///\brief Bucket heap implementation.

#include <vector>

#include <utility>

#include <functional>

namespace lemon {

  namespace _bucket_heap_bits {

    template <bool MIN>

    template <>

    struct DirectionTraits<false> {

      static bool less(int left, int right) {

        return left > right;

      }

      static void increase(int& value) {

        --value;

      }

    };

  }

  ///

  /// \brief Bucket heap data structure.

  ///

  /// This class implements the \e bucket \e heap data structure.

  /// It practically conforms to the \ref concepts::Heap "heap concept",

  /// but it has some limitations.

  ///

  /// The bucket heap is a very simple structure. It can store only

  /// \c int priorities and it maintains a list of items for each priority

  /// in the range <tt>[0..C)</tt>. So it should only be used when the

  /// priorities are small. It is not intended to use as a Dijkstra heap.

  ///

      int value;

      int prev, next;

    };

    ItemIntMap& _iim;

    std::vector<int> _first;

    std::vector<BucketItem> _data;

    mutable int _minimum;

  }; // class BucketHeap

  ///

  /// \brief Simplified bucket heap data structure.

  ///

  /// This class implements a simplified \e bucket \e heap data

  /// structure. It does not provide some functionality, but it is

  /// faster and simpler than BucketHeap. The main difference is

  /// that BucketHeap stores a doubly-linked list for each key while

  /// this class stores only simply-linked lists. It supports erasing

  /// only for the item having minimum priority and it does not support

  /// key increasing and decreasing.

  ///

  /// Note that this implementation does not conform to the

#include <lemon/concept_check.h>

namespace lemon {

  namespace concepts {

    /// \addtogroup concept

    /// @{

    /// \brief The heap concept.

    ///

    /// This concept class describes the main interface of heaps.

    /// implementations of the abstract data type \e priority \e queue.

    /// They store items with specified values called \e priorities

    /// in such a way that finding and removing the item with minimum

    /// priority are efficient. The basic operations are adding and

    /// erasing items, changing the priority of an item, etc.

    ///

    /// Heaps are crucial in several algorithms, such as Dijkstra and Prim.

    /// Any class that conforms to this concept can be used easily in such

    /// algorithms.

    ///

    /// \tparam PR Type of the priorities of the items.

    /// \tparam IM A read-writable item map with \c int values, used

 * precise terms see the accompanying LICENSE file.

 *

 * This software is provided "AS IS" with no warranty of any kind,

 * express or implied, and with no claim as to its suitability for any

 * purpose.

 *

 */

#ifndef LEMON_FIB_HEAP_H

#define LEMON_FIB_HEAP_H

///\file

///\brief Fibonacci heap implementation.

#include <vector>

#include <utility>

#include <functional>

#include <lemon/math.h>

namespace lemon {

  ///

  /// \brief Fibonacci heap data structure.

  ///

  /// This class implements the \e Fibonacci \e heap data structure.

  /// It fully conforms to the \ref concepts::Heap "heap concept".

  ///

  /// The methods \ref increase() and \ref erase() are not efficient in a

  /// Fibonacci heap. In case of many calls of these operations, it is

  /// better to use other heap structure, e.g. \ref BinHeap "binary heap".

  ///

  /// \tparam PR Type of the priorities of the items.

  /// \tparam IM A read-writable item map with \c int values, used

 * provided that this copyright notice appears in all copies. For

 * precise terms see the accompanying LICENSE file.

 *

 * This software is provided "AS IS" with no warranty of any kind,

 * express or implied, and with no claim as to its suitability for any

 * purpose.

 *

 */

#ifndef LEMON_RADIX_HEAP_H

#define LEMON_RADIX_HEAP_H

///\file

///\brief Radix heap implementation.

#include <vector>

#include <lemon/error.h>

namespace lemon {

  ///

  /// \brief Radix heap data structure.

  ///

  /// This class implements the \e radix \e heap data structure.

  /// It practically conforms to the \ref concepts::Heap "heap concept",

  /// but it has some limitations due its special implementation.

  /// The type of the priorities must be \c int and the priority of an

  /// item cannot be decreased under the priority of the last removed item.

  ///

  /// \tparam IM A read-writable item map with \c int values, used

  /// internally to handle the cross references.

  template <typename IM>