RhodeCode

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

#define LEMON_ADAPTORS_H

/// \ingroup graph_adaptors

/// \file

/// \brief Adaptor classes for digraphs and graphs

///

/// This file contains several useful adaptors for digraphs and graphs.

#include <lemon/core.h>

#include <lemon/maps.h>

#include <lemon/bits/variant.h>

#include <lemon/bits/graph_adaptor_extender.h>

#include <lemon/tolerance.h>

#include <algorithm>

namespace lemon {

#ifdef _MSC_VER

#define LEMON_SCOPE_FIX(OUTER, NESTED) OUTER::NESTED

#else

#define LEMON_SCOPE_FIX(OUTER, NESTED) typename OUTER::template NESTED

#endif

  template<typename DGR>

  class DigraphAdaptorBase {

  public:

    typedef DGR Digraph;

    typedef DigraphAdaptorBase Adaptor;

  protected:

    DGR* _digraph;

    DigraphAdaptorBase() : _digraph(0) { }

    void initialize(DGR& digraph) { _digraph = &digraph; }

  public:

    DigraphAdaptorBase(DGR& digraph) : _digraph(&digraph) { }

    typedef typename DGR::Node Node;

    typedef typename DGR::Arc Arc;

    void first(Node& i) const { _digraph->first(i); }

    void first(Arc& i) const { _digraph->first(i); }

    void firstIn(Arc& i, const Node& n) const { _digraph->firstIn(i, n); }

    void firstOut(Arc& i, const Node& n ) const { _digraph->firstOut(i, n); }

    void next(Node& i) const { _digraph->next(i); }

    void next(Arc& i) const { _digraph->next(i); }

    void nextIn(Arc& i) const { _digraph->nextIn(i); }

    void nextOut(Arc& i) const { _digraph->nextOut(i); }

    Node source(const Arc& a) const { return _digraph->source(a); }

    Node target(const Arc& a) const { return _digraph->target(a); }

    typedef NodeNumTagIndicator<DGR> NodeNumTag;

    int nodeNum() const { return _digraph->nodeNum(); }

    typedef ArcNumTagIndicator<DGR> ArcNumTag;

    int arcNum() const { return _digraph->arcNum(); }

    typedef FindArcTagIndicator<DGR> FindArcTag;

    Arc findArc(const Node& u, const Node& v, const Arc& prev = INVALID) const {

      return _digraph->findArc(u, v, prev);

    }

    Node addNode() { return _digraph->addNode(); }

    Arc addArc(const Node& u, const Node& v) { return _digraph->addArc(u, v); }

    void erase(const Node& n) { _digraph->erase(n); }

    void erase(const Arc& a) { _digraph->erase(a); }

    void clear() { _digraph->clear(); }

    int id(const Node& n) const { return _digraph->id(n); }

    int id(const Arc& a) const { return _digraph->id(a); }

    Node nodeFromId(int ix) const { return _digraph->nodeFromId(ix); }

    Arc arcFromId(int ix) const { return _digraph->arcFromId(ix); }

    int maxNodeId() const { return _digraph->maxNodeId(); }

    int maxArcId() const { return _digraph->maxArcId(); }

    typedef typename ItemSetTraits<DGR, Node>::ItemNotifier NodeNotifier;

    NodeNotifier& notifier(Node) const { return _digraph->notifier(Node()); }

    typedef typename ItemSetTraits<DGR, Arc>::ItemNotifier ArcNotifier;

    ArcNotifier& notifier(Arc) const { return _digraph->notifier(Arc()); }

    template <typename V>

    class NodeMap : public DGR::template NodeMap<V> {

    public:

      typedef typename DGR::template NodeMap<V> Parent;

      explicit NodeMap(const Adaptor& adaptor)

        : Parent(*adaptor._digraph) {}

      NodeMap(const Adaptor& adaptor, const V& value)

        : Parent(*adaptor._digraph, value) { }

    private:

      NodeMap& operator=(const NodeMap& cmap) {

        return operator=<NodeMap>(cmap);

      }

      template <typename CMap>

      NodeMap& operator=(const CMap& cmap) {

        Parent::operator=(cmap);

        return *this;

      }

    };

    template <typename V>

    class ArcMap : public DGR::template ArcMap<V> {

    public:

      typedef typename DGR::template ArcMap<V> Parent;

      explicit ArcMap(const DigraphAdaptorBase<DGR>& adaptor)

        : Parent(*adaptor._digraph) {}

      ArcMap(const DigraphAdaptorBase<DGR>& adaptor, const V& value)

        : Parent(*adaptor._digraph, value) {}

    private:

      ArcMap& operator=(const ArcMap& cmap) {

        return operator=<ArcMap>(cmap);

      }

      template <typename CMap>

      ArcMap& operator=(const CMap& cmap) {

        Parent::operator=(cmap);

        return *this;

      }

    };

  };

/* -*- C++ -*-

 *

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

 *

 * Copyright (C) 2003-2008

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

#define LEMON_BITS_EDGE_SET_EXTENDER_H

#include <lemon/error.h>

#include <lemon/bits/default_map.h>

///\ingroup digraphbits

///\file

///\brief Extenders for the arc set types

namespace lemon {

  /// \ingroup digraphbits

  ///

  /// \brief Extender for the ArcSets

  template <typename Base>

  class ArcSetExtender : public Base {

  public:

    typedef Base Parent;

    typedef ArcSetExtender Digraph;

    // Base extensions

    typedef typename Parent::Node Node;

    typedef typename Parent::Arc Arc;

    int maxId(Node) const {

      return Parent::maxNodeId();

    }

    int maxId(Arc) const {

      return Parent::maxArcId();

    }

    Node fromId(int id, Node) const {

      return Parent::nodeFromId(id);

    }

    Arc fromId(int id, Arc) const {

      return Parent::arcFromId(id);

    }

    Node oppositeNode(const Node &n, const Arc &e) const {

      if (n == Parent::source(e))

	return Parent::target(e);

      else if(n==Parent::target(e))

	return Parent::source(e);

      else

	return INVALID;

    }

    // Alteration notifier extensions

    /// The arc observer registry.

    typedef AlterationNotifier<ArcSetExtender, Arc> ArcNotifier;

  protected:

    mutable ArcNotifier arc_notifier;

  public:

    using Parent::notifier;

    /// \brief Gives back the arc alteration notifier.

    ///

    /// Gives back the arc alteration notifier.

    ArcNotifier& notifier(Arc) const {

      return arc_notifier;

    }

    // Iterable extensions

    class NodeIt : public Node { 

      const Digraph* digraph;

    public:

      NodeIt() {}

      NodeIt(Invalid i) : Node(i) { }

      explicit NodeIt(const Digraph& _graph) : digraph(&_graph) {

	_graph.first(static_cast<Node&>(*this));

      }

      NodeIt(const Digraph& _graph, const Node& node) 

	: Node(node), digraph(&_graph) {}

      NodeIt& operator++() { 

	digraph->next(*this);

	return *this; 

      }

    };

    class ArcIt : public Arc { 

      const Digraph* digraph;

    public:

      ArcIt() { }

      ArcIt(Invalid i) : Arc(i) { }

      explicit ArcIt(const Digraph& _graph) : digraph(&_graph) {

	_graph.first(static_cast<Arc&>(*this));

      }

      ArcIt(const Digraph& _graph, const Arc& e) : 

	Arc(e), digraph(&_graph) { }

      ArcIt& operator++() { 

	digraph->next(*this);

	return *this; 

      }

    };

    class OutArcIt : public Arc { 

      const Digraph* digraph;

    public:

      OutArcIt() { }

      OutArcIt(Invalid i) : Arc(i) { }

      OutArcIt(const Digraph& _graph, const Node& node) 

	: digraph(&_graph) {

	_graph.firstOut(*this, node);

      }

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

#define LEMON_BITS_PRED_MAP_PATH_H

namespace lemon {

  template <typename _Digraph, typename _PredMap>

  class PredMapPath {

  public:

    typedef True RevPathTag;

    typedef _Digraph Digraph;

    typedef typename Digraph::Arc Arc;

    typedef _PredMap PredMap;

    PredMapPath(const Digraph& _digraph, const PredMap& _predMap,

                typename Digraph::Node _target)

      : digraph(_digraph), predMap(_predMap), target(_target) {}

    int length() const {

      int len = 0;

      typename Digraph::Node node = target;

      typename Digraph::Arc arc;

      while ((arc = predMap[node]) != INVALID) {

        node = digraph.source(arc);

        ++len;

      }

      return len;

    }

    bool empty() const {

      return predMap[target] != INVALID;

    }

    class RevArcIt {

    public:

      RevArcIt() {}

      RevArcIt(Invalid) : path(0), current(INVALID) {}

      RevArcIt(const PredMapPath& _path)

        : path(&_path), current(_path.target) {

        if (path->predMap[current] == INVALID) current = INVALID;

      }

      operator const typename Digraph::Arc() const {

        return path->predMap[current];

      }

      RevArcIt& operator++() {

        current = path->digraph.source(path->predMap[current]);

        if (path->predMap[current] == INVALID) current = INVALID;

        return *this;

      }

      bool operator==(const RevArcIt& e) const {

        return current == e.current;

      }

      bool operator!=(const RevArcIt& e) const {

        return current != e.current;

      }

      bool operator<(const RevArcIt& e) const {

        return current < e.current;

      }

    private:

      const PredMapPath* path;

      typename Digraph::Node current;

    };

  private:

    const Digraph& digraph;

    const PredMap& predMap;

    typename Digraph::Node target;

  };

  template <typename _Digraph, typename _PredMatrixMap>

  class PredMatrixMapPath {

  public:

    typedef True RevPathTag;

    typedef _Digraph Digraph;

    typedef typename Digraph::Arc Arc;

    typedef _PredMatrixMap PredMatrixMap;

    PredMatrixMapPath(const Digraph& _digraph,

                      const PredMatrixMap& _predMatrixMap,

                      typename Digraph::Node _source,

                      typename Digraph::Node _target)

      : digraph(_digraph), predMatrixMap(_predMatrixMap),

        source(_source), target(_target) {}

    int length() const {

      int len = 0;

      typename Digraph::Node node = target;

      typename Digraph::Arc arc;

      while ((arc = predMatrixMap(source, node)) != INVALID) {

        node = digraph.source(arc);

        ++len;

      }

      return len;

    }

    bool empty() const {

      return source != target;

    }

    class RevArcIt {

    public:

      RevArcIt() {}

      RevArcIt(Invalid) : path(0), current(INVALID) {}

      RevArcIt(const PredMatrixMapPath& _path)

        : path(&_path), current(_path.target) {

        if (path->predMatrixMap(path->source, current) == INVALID)

          current = INVALID;

      }

      operator const typename Digraph::Arc() const {

        return path->predMatrixMap(path->source, current);

      }

      RevArcIt& operator++() {

        current =

          path->digraph.source(path->predMatrixMap(path->source, current));

        if (path->predMatrixMap(path->source, current) == INVALID)

          current = INVALID;

        return *this;

      }

      bool operator==(const RevArcIt& e) const {

        return current == e.current;

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

 *

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

 *

 * Copyright (C) 2003-2008

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

#define LEMON_BITS_SOLVER_BITS_H

namespace lemon {

  namespace _solver_bits {

    class VarIndex {

    private:

      struct ItemT {

        int prev, next;

        int index;

      };

      std::vector<ItemT> items;

      int first_item, last_item, first_free_item;

      std::vector<int> cross;

    public:

      VarIndex()

        : first_item(-1), last_item(-1), first_free_item(-1) {

      }

      void clear() {

        first_item = -1;

        first_free_item = -1;

        items.clear();

        cross.clear();

      }

      int addIndex(int idx) {

        int n;

        if (first_free_item == -1) {

          n = items.size();

          items.push_back(ItemT());

        } else {

          n = first_free_item;

          first_free_item = items[n].next;

          if (first_free_item != -1) {

            items[first_free_item].prev = -1;

          }

        }

        items[n].index = idx;

        if (static_cast<int>(cross.size()) <= idx) {

          cross.resize(idx + 1, -1);

        }

        cross[idx] = n;

        items[n].prev = last_item;

        items[n].next = -1;

        if (last_item != -1) {

          items[last_item].next = n;

        } else {

          first_item = n;

        }

        last_item = n;

        return n;

      }

      int addIndex(int idx, int n) {

        while (n >= static_cast<int>(items.size())) {

          items.push_back(ItemT());

          items.back().prev = -1;

          items.back().next = first_free_item;

          if (first_free_item != -1) {

            items[first_free_item].prev = items.size() - 1;

          }

          first_free_item = items.size() - 1;

        }

        if (items[n].next != -1) {

          items[items[n].next].prev = items[n].prev;

        }

        if (items[n].prev != -1) {

          items[items[n].prev].next = items[n].next;

        } else {

          first_free_item = items[n].next;

        }

        items[n].index = idx;

        if (static_cast<int>(cross.size()) <= idx) {

          cross.resize(idx + 1, -1);

        }

        cross[idx] = n;

        items[n].prev = last_item;

        items[n].next = -1;

        if (last_item != -1) {

          items[last_item].next = n;

        } else {

          first_item = n;

        }

        last_item = n;

        return n;

      }

      void eraseIndex(int idx) {

        int n = cross[idx];

        if (items[n].prev != -1) {

          items[items[n].prev].next = items[n].next;

        } else {

          first_item = items[n].next;

        }

        if (items[n].next != -1) {

          items[items[n].next].prev = items[n].prev;

        } else {

          last_item = items[n].prev;

        }

        if (first_free_item != -1) {

          items[first_free_item].prev = n;

        }

        items[n].next = first_free_item;

        items[n].prev = -1;

        first_free_item = n;

        while (!cross.empty() && cross.back() == -1) {

          cross.pop_back();

        }

      }

      int maxIndex() const {

        return cross.size() - 1;

      }

      void shiftIndices(int idx) {

        for (int i = idx + 1; i < static_cast<int>(cross.size()); ++i) {

          cross[i - 1] = cross[i];

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

 *

 */

///\ingroup concept

///\file

///\brief The concept of heaps.

#ifndef LEMON_CONCEPT_HEAP_H

#define LEMON_CONCEPT_HEAP_H

#include <lemon/core.h>

namespace lemon {

  namespace concepts {

    /// \addtogroup concept

    /// @{

    /// \brief The heap concept.

    ///

    /// Concept class describing the main interface of heaps.

    template <typename Priority, typename ItemIntMap>

    class Heap {

    public:

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

      typedef typename ItemIntMap::Key Item;

      /// Type of the priorities.

      typedef Priority Prio;

      /// \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 later two are indifferent

      /// from the point of view of the heap, but may be useful for

      /// the user.

      ///

      /// The \c ItemIntMap must be initialized in such a way, that it

      /// assigns \c PRE_HEAP (<tt>-1</tt>) to every item.

      enum State {

        IN_HEAP = 0,

        PRE_HEAP = -1,

        POST_HEAP = -2

      };

      /// \brief The constructor.

      ///

      /// The 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 every item.

      explicit Heap(ItemIntMap &map) {}

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

      ///

      /// Returns the number of items stored in the heap.

      int size() const { return 0; }

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

      ///

      /// Returns \c true if the heap is empty.

      bool empty() const { return false; }

      /// \brief Makes the heap empty.

      ///

      /// Makes the heap empty.

      void clear();

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

      ///

      /// Inserts the given item into the heap with the given priority.

      /// \param i The item to insert.

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

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

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

      ///

      /// Returns the item having minimum priority.

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

      Item top() const {}

      /// \brief The minimum priority.

      ///

      /// Returns the minimum priority.

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

      Prio prio() const {}

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

      ///

      /// Removes the item having minimum priority.

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

      void pop() {}

      /// \brief Removes an item from the heap.

      ///

      /// Removes the given item from the heap if it is already stored.

      /// \param i The item to delete.

      void erase(const Item &i) {}

      /// \brief The priority of an item.

      ///

      /// Returns the priority of the given item.

      /// \pre \c i must be in the heap.

      /// \param i The item.

      Prio operator[](const Item &i) const {}

      /// \brief Sets the priority of an item or inserts it, if it is

      /// not stored in the heap.

      ///

      /// This method sets the priority of the given item if it is

      /// already stored in the heap.

      /// Otherwise it inserts the given item with the given priority.

      ///

      /// \param i The item.

      /// \param p The priority.

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

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

      ///

      /// Decreases the priority of an item to the given value.

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

      /// \param i The item.

      /// \param p The priority.

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

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

      ///

      /// Increases the priority of an item to the given value.

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

      /// \param i The item.

      /// \param p The priority.

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

      /// \brief Returns if an item is in, has already been in, or has

      /// never been 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_ELEVATOR_H

#define LEMON_ELEVATOR_H

///\ingroup auxdat

///\file

///\brief Elevator class

///

///Elevator class implements an efficient data structure

///for labeling items in push-relabel type algorithms.

///

#include <lemon/bits/traits.h>

namespace lemon {

  ///Class for handling "labels" in push-relabel type algorithms.

  ///A class for handling "labels" in push-relabel type algorithms.

  ///

  ///\ingroup auxdat

  ///Using this class you can assign "labels" (nonnegative integer numbers)

  ///to the edges or nodes of a graph, manipulate and query them through

  ///operations typically arising in "push-relabel" type algorithms.

  ///

  ///Each item is either \em active or not, and you can also choose a

  ///highest level active item.

  ///

  ///\sa LinkedElevator

  ///

  ///\param Graph Type of the underlying graph.

  ///\param Item Type of the items the data is assigned to (Graph::Node,

  ///Graph::Arc, Graph::Edge).

  template<class Graph, class Item>

  class Elevator

  {

  public:

    typedef Item Key;

    typedef int Value;

  private:

    typedef Item *Vit;

    typedef typename ItemSetTraits<Graph,Item>::template Map<Vit>::Type VitMap;

    typedef typename ItemSetTraits<Graph,Item>::template Map<int>::Type IntMap;

    const Graph &_g;

    int _max_level;

    int _item_num;

    VitMap _where;

    IntMap _level;

    std::vector<Item> _items;

    std::vector<Vit> _first;

    std::vector<Vit> _last_active;

    int _highest_active;

    void copy(Item i, Vit p)

    {

      _where.set(*p=i,p);

    }

    void copy(Vit s, Vit p)

    {

      if(s!=p)

        {

          Item i=*s;

          *p=i;

          _where.set(i,p);

        }

    }

    void swap(Vit i, Vit j)

    {

      Item ti=*i;

      Vit ct = _where[ti];

      _where.set(ti,_where[*i=*j]);

      _where.set(*j,ct);

      *j=ti;

    }

  public:

    ///Constructor with given maximum level.

    ///Constructor with given maximum level.

    ///

    ///\param graph The underlying graph.

    ///\param max_level The maximum allowed level.

    ///Set the range of the possible labels to <tt>[0..max_level]</tt>.

    Elevator(const Graph &graph,int max_level) :

      _g(graph),

      _max_level(max_level),

      _item_num(_max_level),

      _where(graph),

      _level(graph,0),

      _items(_max_level),

      _first(_max_level+2),

      _last_active(_max_level+2),

      _highest_active(-1) {}

    ///Constructor.

    ///Constructor.

    ///

    ///\param graph The underlying graph.

    ///Set the range of the possible labels to <tt>[0..max_level]</tt>,

    ///where \c max_level is equal to the number of labeled items in the graph.

    Elevator(const Graph &graph) :

      _g(graph),

      _max_level(countItems<Graph, Item>(graph)),

      _item_num(_max_level),

      _where(graph),

      _level(graph,0),

      _items(_max_level),

      _first(_max_level+2),

      _last_active(_max_level+2),

      _highest_active(-1)

    {

    }

    ///Activate item \c i.

    ///Activate item \c i.

    ///\pre Item \c i shouldn't be active before.

    void activate(Item i)

    {

      const int l=_level[i];

      swap(_where[i],++_last_active[l]);

      if(l>_highest_active) _highest_active=l;

    }

    ///Deactivate item \c i.

    ///Deactivate item \c i.

    ///\pre Item \c i must be active before.

    void deactivate(Item i)

    {

      swap(_where[i],_last_active[_level[i]]--);

      while(_highest_active>=0 &&

            _last_active[_highest_active]<_first[_highest_active])

        _highest_active--;

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

#define LEMON_SUURBALLE_H

///\ingroup shortest_path

///\file

///\brief An algorithm for finding arc-disjoint paths between two

/// nodes having minimum total length.

#include <vector>

#include <lemon/bin_heap.h>

#include <lemon/path.h>

namespace lemon {

  /// \addtogroup shortest_path

  /// @{

  /// \brief Algorithm for finding arc-disjoint paths between two nodes

  /// having minimum total length.

  ///

  /// \ref lemon::Suurballe "Suurballe" implements an algorithm for

  /// finding arc-disjoint paths having minimum total length (cost)

  /// from a given source node to a given target node in a digraph.

  ///

  /// In fact, this implementation is the specialization of the

  /// \ref CapacityScaling "successive shortest path" algorithm.

  ///

  /// \tparam Digraph The digraph type the algorithm runs on.

  /// The default value is \c ListDigraph.

  /// \tparam LengthMap The type of the length (cost) map.

  /// The default value is <tt>Digraph::ArcMap<int></tt>.

  ///

  /// \warning Length values should be \e non-negative \e integers.

  ///

  /// \note For finding node-disjoint paths this algorithm can be used

  /// with \ref SplitNodes.

#ifdef DOXYGEN

  template <typename Digraph, typename LengthMap>

#else

  template < typename Digraph = ListDigraph,

             typename LengthMap = typename Digraph::template ArcMap<int> >

#endif

  class Suurballe

  {

    TEMPLATE_DIGRAPH_TYPEDEFS(Digraph);

    typedef typename LengthMap::Value Length;

    typedef ConstMap<Arc, int> ConstArcMap;

    typedef typename Digraph::template NodeMap<Arc> PredMap;

  public:

    /// The type of the flow map.

    typedef typename Digraph::template ArcMap<int> FlowMap;

    /// The type of the potential map.

    typedef typename Digraph::template NodeMap<Length> PotentialMap;

    /// The type of the path structures.

    typedef SimplePath<Digraph> Path;

  private:

    /// \brief Special implementation of the Dijkstra algorithm

    /// for finding shortest paths in the residual network.

    ///

    /// \ref ResidualDijkstra is a special implementation of the

    /// \ref Dijkstra algorithm for finding shortest paths in the

    /// residual network of the digraph with respect to the reduced arc

    /// lengths and modifying the node potentials according to the

    /// distance of the nodes.

    class ResidualDijkstra

    {

      typedef typename Digraph::template NodeMap<int> HeapCrossRef;

      typedef BinHeap<Length, HeapCrossRef> Heap;

    private:

      // The digraph the algorithm runs on

      const Digraph &_graph;

      // The main maps

      const FlowMap &_flow;

      const LengthMap &_length;

      PotentialMap &_potential;

      // The distance map

      PotentialMap _dist;

      // The pred arc map

      PredMap &_pred;

      // The processed (i.e. permanently labeled) nodes

      std::vector<Node> _proc_nodes;

      Node _s;

      Node _t;

    public:

      /// Constructor.

      ResidualDijkstra( const Digraph &digraph,

                        const FlowMap &flow,

                        const LengthMap &length,

                        PotentialMap &potential,

                        PredMap &pred,

                        Node s, Node t ) :

        _graph(digraph), _flow(flow), _length(length), _potential(potential),

        _dist(digraph), _pred(pred), _s(s), _t(t) {}

      /// \brief Run the algorithm. It returns \c true if a path is found

      /// from the source node to the target node.

      bool run() {

        HeapCrossRef heap_cross_ref(_graph, Heap::PRE_HEAP);

        Heap heap(heap_cross_ref);

        heap.push(_s, 0);

        _pred[_s] = INVALID;

        _proc_nodes.clear();

        // Process nodes

        while (!heap.empty() && heap.top() != _t) {

          Node u = heap.top(), v;

          Length d = heap.prio() + _potential[u], nd;

          _dist[u] = heap.prio();

          heap.pop();

          _proc_nodes.push_back(u);

          // Traverse outgoing arcs

          for (OutArcIt e(_graph, u); e != INVALID; ++e) {

            if (_flow[e] == 0) {

              v = _graph.target(e);

              switch(heap.state(v)) {

              case Heap::PRE_HEAP:

                heap.push(v, d + _length[e] - _potential[v]);

                _pred[v] = e;

                break;

              case Heap::IN_HEAP:

                nd = d + _length[e] - _potential[v];

                if (nd < heap[v]) {

                  heap.decrease(v, nd);

                  _pred[v] = e;

                }

                break;