RhodeCode

int algorithm1(const ListDigraph& g) {

  ReverseDigraph<const ListDigraph> rg(g);

  return algorithm2(rg);

}

\endcode

*/

/**

@defgroup maps Maps

@ingroup datas

\brief Map structures implemented in LEMON.

This group contains the map structures implemented in LEMON.

LEMON provides several special purpose maps and map adaptors that e.g. combine

new maps from existing ones.

<b>See also:</b> \ref map_concepts "Map Concepts".

*/

/**

@defgroup graph_maps Graph Maps

@ingroup maps

\brief Special graph-related maps.

This group contains maps that are specifically designed to assign

values to the nodes and arcs/edges of graphs.

If you are looking for the standard graph maps (\c NodeMap, \c ArcMap,

\c EdgeMap), see the \ref graph_concepts "Graph Structure Concepts".

*/

/**

\defgroup map_adaptors Map Adaptors

\ingroup maps

\brief Tools to create new maps from existing ones

This group contains map adaptors that are used to create "implicit"

maps from other maps.

Most of them are \ref concepts::ReadMap "read-only maps".

They can make arithmetic and logical operations between one or two maps

(negation, shifting, addition, multiplication, logical 'and', 'or',

'not' etc.) or e.g. convert a map to another one of different Value type.

The typical usage of this classes is passing implicit maps to

algorithms.  If a function type algorithm is called then the function

type map adaptors can be used comfortable. For example let's see the

usage of map adaptors with the \c graphToEps() function.

\code

  Color nodeColor(int deg) {

    if (deg >= 2) {

      return Color(0.5, 0.0, 0.5);

    } else if (deg == 1) {

      return Color(1.0, 0.5, 1.0);

    } else {

      return Color(0.0, 0.0, 0.0);

    }

  }

  Digraph::NodeMap<int> degree_map(graph);

  graphToEps(graph, "graph.eps")

    .coords(coords).scaleToA4().undirected()

    .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

\brief Algorithms for finding shortest paths.

This group contains the algorithms for finding shortest paths in digraphs.

 - \ref Dijkstra algorithm for finding shortest paths from a source node

   when all arc lengths are non-negative.

 - \ref BellmanFord "Bellman-Ford" algorithm for finding shortest paths

   from a source node when arc lenghts can be either positive or negative,

   but the digraph should not contain directed cycles with negative total

   length.

 - \ref FloydWarshall "Floyd-Warshall" and \ref Johnson "Johnson" algorithms

   for solving the \e all-pairs \e shortest \e paths \e problem when arc

   lenghts can be either positive or negative, but the digraph should

   not contain directed cycles with negative total length.

 - \ref Suurballe A successive shortest path algorithm for finding

   arc-disjoint paths between two nodes having minimum total length.

*/

/**

@defgroup max_flow Maximum Flow Algorithms

@ingroup algs

\brief Algorithms for finding maximum flows.

This group contains the algorithms for finding maximum flows and

feasible circulations.

The \e maximum \e flow \e problem is to find a flow of maximum value between

a single source and a single target. Formally, there is a \f$G=(V,A)\f$

digraph, a \f$cap: A\rightarrow\mathbf{R}^+_0\f$ capacity function and

\f$s, t \in V\f$ source and target nodes.

A maximum flow is an \f$f: A\rightarrow\mathbf{R}^+_0\f$ solution of the

following optimization problem.

\f[ \max\sum_{sv\in A} f(sv) - \sum_{vs\in A} f(vs) \f]

\f[ \sum_{uv\in A} f(uv) = \sum_{vu\in A} f(vu)

    \quad \forall u\in V\setminus\{s,t\} \f]

\f[ 0 \leq f(uv) \leq cap(uv) \quad \forall uv\in A \f]

LEMON contains several algorithms for solving maximum flow problems:

- \ref EdmondsKarp Edmonds-Karp algorithm.

- \ref Preflow Goldberg-Tarjan's preflow push-relabel algorithm.

- \ref DinitzSleatorTarjan Dinitz's blocking flow algorithm with dynamic trees.

- \ref GoldbergTarjan Preflow push-relabel algorithm with dynamic trees.

In most cases the \ref Preflow "Preflow" algorithm provides the

fastest method for computing a maximum flow. All implementations

also provide functions to query the minimum cut, which is the dual

problem of maximum flow.

\ref Circulation is a preflow push-relabel algorithm implemented directly 

for finding feasible circulations, which is a somewhat different problem,

but it is strongly related to maximum flow.

For more information, see \ref Circulation.

*/

/**

@defgroup min_cost_flow_algs Minimum Cost Flow Algorithms

@ingroup algs

\brief Algorithms for finding minimum cost flows and circulations.

This group contains the algorithms for finding minimum cost flows and

circulations. For more information about this problem and its dual

solution see \ref min_cost_flow "Minimum Cost Flow Problem".

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

    ///

    /// Each item has a state associated to it. It can be "in heap",

    /// "pre-heap" or "post-heap". The latter two are indifferent from the

    /// heap's point of view, but may be useful to the user.

    ///

    /// The item-int map must be initialized in such way that it assigns

    /// \c PRE_HEAP (<tt>-1</tt>) to any element to be put in the heap.

    enum State {

      IN_HEAP = 0,    ///< = 0.

      PRE_HEAP = -1,  ///< = -1.

      POST_HEAP = -2  ///< = -2.

    };

  private:

    std::vector<Pair> _data;

    Compare _comp;

    ItemIntMap &_iim;

  public:

    /// \brief Constructor.

    ///

    /// Constructor.

    /// \param map A map that assigns \c int values to the items.

    /// It is used internally to handle the cross references.

    /// The assigned value must be \c PRE_HEAP (<tt>-1</tt>) for each item.

    explicit BinHeap(ItemIntMap &map) : _iim(map) {}

    /// \brief Constructor.

    ///

    /// Constructor.

    /// \param map A map that assigns \c int values to the items.

    /// It is used internally to handle the cross references.

    /// The assigned value must be \c PRE_HEAP (<tt>-1</tt>) for each item.

    /// \param comp The function object used for comparing the priorities.

    BinHeap(ItemIntMap &map, const Compare &comp)

      : _iim(map), _comp(comp) {}

    /// \brief The number of items stored in the heap.

    ///

    /// This function returns the number of items stored in the heap.

    int size() const { return _data.size(); }

    /// \brief Check if the heap is empty.

    ///

    /// This function returns \c true if the heap is empty.

    bool empty() const { return _data.empty(); }

    /// \brief Make the heap empty.

    ///

    /// This functon makes the heap empty.

    /// It does not change the cross reference map. If you want to reuse

    /// a heap that is not surely empty, you should first clear it and

    /// then you should set the cross reference map to \c PRE_HEAP

    /// for each item.

    void clear() {

      _data.clear();

    }

  private:

    static int parent(int i) { return (i-1)/2; }

    static int second_child(int i) { return 2*i+2; }

    bool less(const Pair &p1, const Pair &p2) const {

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

    /// Type of the item-priority pairs.

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

  private:

    typedef _bucket_heap_bits::DirectionTraits<MIN> Direction;

  public:

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

    ///

    /// Each item has a state associated to it. It can be "in heap",

    /// "pre-heap" or "post-heap". The latter two are indifferent from the

    /// heap's point of view, but may be useful to the user.

    ///

    /// The item-int map must be initialized in such way that it assigns

    /// \c PRE_HEAP (<tt>-1</tt>) to any element to be put in the heap.

    enum State {

      IN_HEAP = 0,    ///< = 0.

      PRE_HEAP = -1,  ///< = -1.

      POST_HEAP = -2  ///< = -2.

    };

  public:

    /// \brief Constructor.

    ///

    /// Constructor.

    /// \param map A map that assigns \c int values to the items.

    /// It is used internally to handle the cross references.

    /// The assigned value must be \c PRE_HEAP (<tt>-1</tt>) for each item.

    explicit BucketHeap(ItemIntMap &map) : _iim(map), _minimum(0) {}

    /// \brief The number of items stored in the heap.

    ///

    /// This function returns the number of items stored in the heap.

    int size() const { return _data.size(); }

    /// \brief Check if the heap is empty.

    ///

    /// This function returns \c true if the heap is empty.

    bool empty() const { return _data.empty(); }

    /// \brief Make the heap empty.

    ///

    /// This functon makes the heap empty.

    /// It does not change the cross reference map. If you want to reuse

    /// a heap that is not surely empty, you should first clear it and

    /// then you should set the cross reference map to \c PRE_HEAP

    /// for each item.

    void clear() {

      _data.clear(); _first.clear(); _minimum = 0;

    }

  private:

    void relocate_last(int idx) {

      if (idx + 1 < int(_data.size())) {

        _data[idx] = _data.back();

        if (_data[idx].prev != -1) {

          _data[_data[idx].prev].next = idx;

        } else {

          _first[_data[idx].value] = idx;

        }

    /// \param i The item.

    /// \param p The priority.

    void set(const Item &i, const Prio &p) {

      int idx = _iim[i];

      if (idx < 0) {

        push(i, p);

      } else if (Direction::less(p, _data[idx].value)) {

        decrease(i, p);

      } else {

        increase(i, p);

      }

    }

    /// \brief Decrease the priority of an item to the given value.

    ///

    /// This function decreases the priority of an item to the given value.

    /// \param i The item.

    /// \param p The priority.

    /// \pre \e i must be stored in the heap with priority at least \e p.

    void decrease(const Item &i, const Prio &p) {

      int idx = _iim[i];

      unlace(idx);

      _data[idx].value = p;

      if (Direction::less(p, _minimum)) {

        _minimum = p;

      }

      lace(idx);

    }

    /// \brief Increase the priority of an item to the given value.

    ///

    /// This function increases the priority of an item to the given value.

    /// \param i The item.

    /// \param p The priority.

    /// \pre \e i must be stored in the heap with priority at most \e p.

    void increase(const Item &i, const Prio &p) {

      int idx = _iim[i];

      unlace(idx);

      _data[idx].value = p;

      lace(idx);

    }

    /// \brief Return the state of an item.

    ///

    /// This method returns \c PRE_HEAP if the given item has never

    /// been in the heap, \c IN_HEAP if it is in the heap at the moment,

    /// and \c POST_HEAP otherwise.

    /// In the latter case it is possible that the item will get back

    /// to the heap again.

    /// \param i The item.

    State state(const Item &i) const {

      int idx = _iim[i];

      if (idx >= 0) idx = 0;

      return State(idx);

    }

    /// \brief Set the state of an item in the heap.

    ///

    /// This function sets the state of the given item in the heap.

    /// It can be used to manually clear the heap when it is important

    /// to achive better time complexity.

    /// \param i The item.

    /// \param st The state. It should not be \c IN_HEAP.

    void state(const Item& i, State st) {

      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.

    typedef int 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;

  private:

    typedef _bucket_heap_bits::DirectionTraits<MIN> Direction;

  public:

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

    ///

    /// Each item has a state associated to it. It can be "in heap",

    /// "pre-heap" or "post-heap". The latter two are indifferent from the

    /// heap's point of view, but may be useful to the user.

    ///

    /// The item-int map must be initialized in such way that it assigns

    /// \c PRE_HEAP (<tt>-1</tt>) to any element to be put in the heap.

    enum State {

      IN_HEAP = 0,    ///< = 0.

      PRE_HEAP = -1,  ///< = -1.

      POST_HEAP = -2  ///< = -2.

    };

  public:

    /// \brief Constructor.

    ///

    /// Constructor.

    /// \param map A map that assigns \c int values to the items.

    /// It is used internally to handle the cross references.

    /// The assigned value must be \c PRE_HEAP (<tt>-1</tt>) for each item.

    explicit SimpleBucketHeap(ItemIntMap &map)

      : _iim(map), _free(-1), _num(0), _minimum(0) {}

    /// \brief The number of items stored in the heap.

    ///

    /// This function returns the number of items stored in the heap.

    int size() const { return _num; }

    /// \brief Check if the heap is empty.

    ///

    /// This function returns \c true if the heap is empty.

    bool empty() const { return _num == 0; }

    /// \brief Make the heap empty.

    ///

    /// This functon makes the heap empty.

    /// It does not change the cross reference map. If you want to reuse

    /// a heap that is not surely empty, you should first clear it and

    /// then you should set the cross reference map to \c PRE_HEAP

    /// for each item.

    void clear() {

      _data.clear(); _first.clear(); _free = -1; _num = 0; _minimum = 0;

    }

    /// \brief Insert a pair of item and priority into the heap.

    ///

    /// This function inserts \c p.first to the heap with priority

    /// \c p.second.

    /// \param p The pair to insert.

    /// \pre \c p.first must not be stored in the heap.

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

      ///

      /// Each item has a state associated to it. It can be "in heap",

      /// "pre-heap" or "post-heap". The latter two are indifferent from the

      /// heap's point of view, but may be useful to the user.

      ///

      /// The item-int map must be initialized in such way that it assigns

      /// \c PRE_HEAP (<tt>-1</tt>) to any element to be put in the heap.

      enum State {

        IN_HEAP = 0,    ///< = 0. The "in heap" state constant.

        PRE_HEAP = -1,  ///< = -1. The "pre-heap" state constant.

        POST_HEAP = -2  ///< = -2. The "post-heap" state constant.

      };

      /// \brief Constructor.

      ///

      /// Constructor.

      /// \param map A map that assigns \c int values to keys of type

      /// \c Item. It is used internally by the heap implementations to

      /// handle the cross references. The assigned value must be

      /// \c PRE_HEAP (<tt>-1</tt>) for each item.

      explicit Heap(ItemIntMap &map) {}

      /// \brief Constructor.

      ///

      /// Constructor.

      /// \param map A map that assigns \c int values to keys of type

      /// \c Item. It is used internally by the heap implementations to

      /// handle the cross references. The assigned value must be

      /// \c PRE_HEAP (<tt>-1</tt>) for each item.

      /// \param comp The function object used for comparing the priorities.

      explicit Heap(ItemIntMap &map, const CMP &comp) {}

      /// \brief The number of items stored in the heap.

      ///

      /// This function returns the number of items stored in the heap.

      int size() const { return 0; }

      /// \brief Check if the heap is empty.

      ///

      /// This function returns \c true if the heap is empty.

      bool empty() const { return false; }

      /// \brief Make the heap empty.

      ///

      /// This functon makes the heap empty.

      /// It does not change the cross reference map. If you want to reuse

      /// a heap that is not surely empty, you should first clear it and

      /// then you should set the cross reference map to \c PRE_HEAP

      /// for each item.

      void clear() {}

      /// \brief Insert an item into the heap with the given priority.

      ///

      /// This function inserts the given item into the heap with the

      /// given priority.

      /// \param i The item to insert.

      /// \param p The priority of the item.

      /// \pre \e i must not be stored in the heap.

      void push(const Item &i, const Prio &p) {}

      /// \brief Return the item having minimum priority.

      ///

      /// This function returns the item having minimum priority.

      /// \pre The heap must be non-empty.

      Item top() const {}

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

    typedef CMP Compare;

  private:

    class Store;

    std::vector<Store> _data;

    int _minimum;

    ItemIntMap &_iim;

    Compare _comp;

    int _num;

  public:

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

    ///

    /// Each item has a state associated to it. It can be "in heap",

    /// "pre-heap" or "post-heap". The latter two are indifferent from the

    /// heap's point of view, but may be useful to the user.

    ///

    /// The item-int map must be initialized in such way that it assigns

    /// \c PRE_HEAP (<tt>-1</tt>) to any element to be put in the heap.

    enum State {

      IN_HEAP = 0,    ///< = 0.

      PRE_HEAP = -1,  ///< = -1.

      POST_HEAP = -2  ///< = -2.

    };

    /// \brief Constructor.

    ///

    /// Constructor.

    /// \param map A map that assigns \c int values to the items.

    /// It is used internally to handle the cross references.

    /// The assigned value must be \c PRE_HEAP (<tt>-1</tt>) for each item.

    explicit FibHeap(ItemIntMap &map)

      : _minimum(0), _iim(map), _num() {}

    /// \brief Constructor.

    ///

    /// Constructor.

    /// \param map A map that assigns \c int values to the items.

    /// It is used internally to handle the cross references.

    /// The assigned value must be \c PRE_HEAP (<tt>-1</tt>) for each item.

    /// \param comp The function object used for comparing the priorities.

    FibHeap(ItemIntMap &map, const Compare &comp)

      : _minimum(0), _iim(map), _comp(comp), _num() {}

    /// \brief The number of items stored in the heap.

    ///

    /// This function returns the number of items stored in the heap.

    int size() const { return _num; }

    /// \brief Check if the heap is empty.

    ///

    /// This function returns \c true if the heap is empty.

    bool empty() const { return _num==0; }

    /// \brief Make the heap empty.

    ///

    /// This functon makes the heap empty.

    /// It does not change the cross reference map. If you want to reuse

    /// a heap that is not surely empty, you should first clear it and

    /// then you should set the cross reference map to \c PRE_HEAP

    /// for each item.

    void clear() {

/* -*- 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";

      }

    };

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

    ///

    /// Each item has a state associated to it. It can be "in heap",

    /// "pre-heap" or "post-heap". The latter two are indifferent from the

    /// heap's point of view, but may be useful to the user.

    ///

    /// The item-int map must be initialized in such way that it assigns

    /// \c PRE_HEAP (<tt>-1</tt>) to any element to be put in the heap.

    enum State {

      IN_HEAP = 0,    ///< = 0.

      PRE_HEAP = -1,  ///< = -1.

      POST_HEAP = -2  ///< = -2.

    };

  private:

    struct RadixItem {

      int prev, next, box;

      Item item;

      int prio;

      RadixItem(Item _item, int _prio) : item(_item), prio(_prio) {}

    };

    struct RadixBox {

      int first;

      int min, size;

      RadixBox(int _min, int _size) : first(-1), min(_min), size(_size) {}

    };

    std::vector<RadixItem> data;

    std::vector<RadixBox> boxes;

    ItemIntMap &_iim;