RhodeCode

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.

 *

 */

#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".

  ///

 *

 */

#ifndef LEMON_BUCKET_HEAP_H

#define LEMON_BUCKET_HEAP_H

///\file

///\brief Bucket heap implementation.

#include <vector>

#include <utility>

#include <functional>

        --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.

    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

    /// \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.

    ///

 */

#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".

  ///

 *

 */

#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.