RhodeCode

    .nodeColors(composeMap(functorToMap(nodeColor), degree_map))

    .run();

\endcode

The \c functorToMap() function makes an \c int to \c Color map from the

\c nodeColor() function. The \c composeMap() compose the \c degree_map

and the previously created map. The composed map is a proper function to

get the color of each node.

The usage with class type algorithms is little bit harder. In this

case the function type map adaptors can not be used, because the

function map adaptors give back temporary objects.

\code

  Digraph graph;

  typedef Digraph::ArcMap<double> DoubleArcMap;

  DoubleArcMap length(graph);

  DoubleArcMap speed(graph);

  typedef DivMap<DoubleArcMap, DoubleArcMap> TimeMap;

  TimeMap time(length, speed);

  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.

*/

/**

@defgroup algs Algorithms

\brief This group contains the several algorithms

implemented in LEMON.

This group contains the several algorithms

implemented in LEMON.

*/

/**

@defgroup search Graph Search

@ingroup algs

\brief Common graph search algorithms.

This group contains the common graph search algorithms, namely

\e breadth-first \e search (BFS) and \e depth-first \e search (DFS).

*/

/**

@defgroup shortest_path Shortest Path Algorithms

@ingroup algs

/* -*- mode: C++; indent-tabs-mode: nil; -*-

 *

 * This file is a part of LEMON, a generic C++ optimization library.

 *

 * Copyright (C) 2003-2009

 * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport

 * (Egervary Research Group on Combinatorial Optimization, EGRES).

 *

 * Permission to use, modify and distribute this software is granted

 * 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

  template <typename PR, typename IM, typename CMP>

#else

  template <typename PR, typename IM, typename CMP = std::less<PR> >

#endif

  class BinHeap {

  public:

    /// Type of the item-int map.

    typedef IM ItemIntMap;

    /// Type of the priorities.

    typedef PR Prio;

    /// Type of the items stored in the heap.

    typedef typename ItemIntMap::Key Item;

    /// Type of the item-priority pairs.

    typedef std::pair<Item,Prio> Pair;

    /// Functor type for comparing the priorities.

    typedef CMP Compare;

    /// \brief Type to represent the states of the items.

    ///

/* -*- mode: C++; indent-tabs-mode: nil; -*-

 *

 * This file is a part of LEMON, a generic C++ optimization library.

 *

 * Copyright (C) 2003-2009

 * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport

 * (Egervary Research Group on Combinatorial Optimization, EGRES).

 *

 * Permission to use, modify and distribute this software is granted

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

    struct DirectionTraits {

      static bool less(int left, int right) {

        return left < right;

      }

      static void increase(int& value) {

        ++value;

      }

    };

    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.

  ///

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

  /// internally to handle the cross references.

  /// \tparam MIN Indicate if the heap is a \e min-heap or a \e max-heap.

  /// The default is \e min-heap. If this parameter is set to \c false,

  /// then the comparison is reversed, so the top(), prio() and pop()

  /// functions deal with the item having maximum priority instead of the

  /// minimum.

  ///

  /// \sa SimpleBucketHeap

  template <typename IM, bool MIN = true>

  class BucketHeap {

  public:

    /// Type of the item-int map.

    typedef IM ItemIntMap;

    /// Type of the priorities.

    typedef int Prio;

    /// Type of the items stored in the heap.

    typedef typename ItemIntMap::Key Item;

      switch (st) {

      case POST_HEAP:

      case PRE_HEAP:

        if (state(i) == IN_HEAP) {

          erase(i);

        }

        _iim[i] = st;

        break;

      case IN_HEAP:

        break;

      }

    }

  private:

    struct BucketItem {

      BucketItem(const Item& _item, int _value)

        : item(_item), value(_value) {}

      Item item;

      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

  /// \ref concepts::Heap "heap concept" due to the lack of some 

  /// functionality.

  ///

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

  /// internally to handle the cross references.

  /// \tparam MIN Indicate if the heap is a \e min-heap or a \e max-heap.

  /// The default is \e min-heap. If this parameter is set to \c false,

  /// then the comparison is reversed, so the top(), prio() and pop()

  /// functions deal with the item having maximum priority instead of the

  /// minimum.

  ///

  /// \sa BucketHeap

  template <typename IM, bool MIN = true >

  class SimpleBucketHeap {

  public:

    /// Type of the item-int map.

    typedef IM ItemIntMap;

    /// Type of the priorities.

 * (Egervary Research Group on Combinatorial Optimization, EGRES).

 *

 * Permission to use, modify and distribute this software is granted

 * 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_CONCEPTS_HEAP_H

#define LEMON_CONCEPTS_HEAP_H

///\ingroup concept

///\file

///\brief The concept of heaps.

#include <lemon/core.h>

#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

    /// internally to handle the cross references.

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

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

#ifdef DOXYGEN

    template <typename PR, typename IM, typename CMP>

#else

    template <typename PR, typename IM, typename CMP = std::less<PR> >

#endif

    class Heap {

    public:

      /// Type of the item-int map.

      typedef IM ItemIntMap;

      /// Type of the priorities.

      typedef PR Prio;

      /// Type of the items stored in the heap.

      typedef typename ItemIntMap::Key Item;

      /// \brief Type to represent the states of the items.

      ///

/* -*- mode: C++; indent-tabs-mode: nil; -*-

 *

 * This file is a part of LEMON, a generic C++ optimization library.

 *

 * Copyright (C) 2003-2009

 * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport

 * (Egervary Research Group on Combinatorial Optimization, EGRES).

 *

 * Permission to use, modify and distribute this software is granted

 * 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_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

  /// internally to handle the cross references.

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

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

#ifdef DOXYGEN

  template <typename PR, typename IM, typename CMP>

#else

  template <typename PR, typename IM, typename CMP = std::less<PR> >

#endif

  class FibHeap {

  public:

    /// Type of the item-int map.

    typedef IM ItemIntMap;

    /// Type of the priorities.

    typedef PR Prio;

    /// Type of the items stored in the heap.

    typedef typename ItemIntMap::Key Item;

    /// Type of the item-priority pairs.

    typedef std::pair<Item,Prio> Pair;

    /// Functor type for comparing the priorities.

/* -*- mode: C++; indent-tabs-mode: nil; -*-

 *

 * This file is a part of LEMON, a generic C++ optimization library.

 *

 * Copyright (C) 2003-2009

 * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport

 * (Egervary Research Group on Combinatorial Optimization, EGRES).

 *

 * Permission to use, modify and distribute this software is granted

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

  class RadixHeap {

  public:

    /// Type of the item-int map.

    typedef IM ItemIntMap;

    /// Type of the priorities.

    typedef int Prio;

    /// Type of the items stored in the heap.

    typedef typename ItemIntMap::Key Item;

    /// \brief Exception thrown by RadixHeap.

    ///

    /// This exception is thrown when an item is inserted into a

    /// RadixHeap with a priority smaller than the last erased one.

    /// \see RadixHeap

    class UnderFlowPriorityError : public Exception {

    public:

      virtual const char* what() const throw() {

        return "lemon::RadixHeap::UnderFlowPriorityError";