/* -*- 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_NAGAMOCHI_IBARAKI_H
#define LEMON_NAGAMOCHI_IBARAKI_H


/// \ingroup min_cut
/// \file 
/// \brief Maximum cardinality search and minimum cut in undirected
/// graphs.

#include <lemon/list_graph.h>
#include <lemon/bin_heap.h>
#include <lemon/bucket_heap.h>

#include <lemon/unionfind.h>
#include <lemon/topology.h>

#include <lemon/bits/invalid.h>
#include <lemon/error.h>
#include <lemon/maps.h>

#include <functional>

#include <lemon/graph_writer.h>
#include <lemon/time_measure.h>

namespace lemon {

  namespace _min_cut_bits {

    template <typename CapacityMap>
    struct HeapSelector {
      template <typename Value, typename Ref>
      struct Selector {
        typedef BinHeap<Value, Ref, std::greater<Value> > Heap;
      };
    };

    template <typename CapacityKey>
    struct HeapSelector<ConstMap<CapacityKey, Const<int, 1> > > {
      template <typename Value, typename Ref>
      struct Selector {
        typedef BucketHeap<Ref, false > Heap;
      };
    };

  }

  /// \brief Default traits class of MaxCardinalitySearch class.
  ///
  /// Default traits class of MaxCardinalitySearch class.
  /// \param Graph Graph type.
  /// \param CapacityMap Type of length map.
  template <typename _Graph, typename _CapacityMap>
  struct MaxCardinalitySearchDefaultTraits {
    /// The graph type the algorithm runs on. 
    typedef _Graph Graph;

    /// \brief The type of the map that stores the edge capacities.
    ///
    /// The type of the map that stores the edge capacities.
    /// It must meet the \ref concepts::ReadMap "ReadMap" concept.
    typedef _CapacityMap CapacityMap;

    /// \brief The type of the capacity of the edges.
    typedef typename CapacityMap::Value Value;

    /// \brief The cross reference type used by heap.
    ///
    /// The cross reference type used by heap.
    /// Usually it is \c Graph::NodeMap<int>.
    typedef typename Graph::template NodeMap<int> HeapCrossRef;

    /// \brief Instantiates a HeapCrossRef.
    ///
    /// This function instantiates a \ref HeapCrossRef. 
    /// \param graph is the graph, to which we would like to define the 
    /// HeapCrossRef.
    static HeapCrossRef *createHeapCrossRef(const Graph &graph) {
      return new HeapCrossRef(graph);
    }
    
    /// \brief The heap type used by MaxCardinalitySearch algorithm.
    ///
    /// The heap type used by MaxCardinalitySearch algorithm. It should
    /// maximalize the priorities. The default heap type is
    /// the \ref BinHeap, but it is specialized when the
    /// CapacityMap is ConstMap<Graph::Node, Const<int, 1> >
    /// to BucketHeap.
    ///
    /// \sa MaxCardinalitySearch
    typedef typename _min_cut_bits
    ::HeapSelector<CapacityMap>
    ::template Selector<Value, HeapCrossRef>
    ::Heap Heap;

    /// \brief Instantiates a Heap.
    ///
    /// This function instantiates a \ref Heap. 
    /// \param crossref The cross reference of the heap.
    static Heap *createHeap(HeapCrossRef& crossref) {
      return new Heap(crossref);
    }

    /// \brief The type of the map that stores whether a nodes is processed.
    ///
    /// The type of the map that stores whether a nodes is processed.
    /// It must meet the \ref concepts::WriteMap "WriteMap" concept.
    /// By default it is a NullMap.
    typedef NullMap<typename Graph::Node, bool> ProcessedMap;

    /// \brief Instantiates a ProcessedMap.
    ///
    /// This function instantiates a \ref ProcessedMap. 
    /// \param graph is the graph, to which
    /// we would like to define the \ref ProcessedMap
#ifdef DOXYGEN
    static ProcessedMap *createProcessedMap(const Graph &graph)
#else
    static ProcessedMap *createProcessedMap(const Graph &)
#endif
    {
      return new ProcessedMap();
    }

    /// \brief The type of the map that stores the cardinalties of the nodes.
    /// 
    /// The type of the map that stores the cardinalities of the nodes.
    /// It must meet the \ref concepts::WriteMap "WriteMap" concept.
    typedef typename Graph::template NodeMap<Value> CardinalityMap;

    /// \brief Instantiates a CardinalityMap.
    ///
    /// This function instantiates a \ref CardinalityMap. 
    /// \param graph is the graph, to which we would like to define the \ref 
    /// CardinalityMap
    static CardinalityMap *createCardinalityMap(const Graph &graph) {
      return new CardinalityMap(graph);
    }


  };
  
  /// \ingroup search
  ///
  /// \brief Maximum Cardinality Search algorithm class.
  ///
  /// This class provides an efficient implementation of Maximum Cardinality 
  /// Search algorithm. The maximum cardinality search chooses first time any 
  /// node of the graph. Then every time it chooses the node which is connected
  /// to the processed nodes at most in the sum of capacities on the out 
  /// edges. If there is a cut in the graph the algorithm should choose
  /// again any unprocessed node of the graph. Each node cardinality is
  /// the sum of capacities on the out edges to the nodes which are processed
  /// before the given node.
  ///
  /// The edge capacities are passed to the algorithm using a
  /// \ref concepts::ReadMap "ReadMap", so it is easy to change it to any 
  /// kind of capacity.
  ///
  /// The type of the capacity is determined by the \ref 
  /// concepts::ReadMap::Value "Value" of the capacity map.
  ///
  /// It is also possible to change the underlying priority heap.
  ///
  ///
  /// \param _Graph The graph type the algorithm runs on. The default value
  /// is \ref ListGraph. The value of Graph is not used directly by
  /// the search algorithm, it is only passed to 
  /// \ref MaxCardinalitySearchDefaultTraits.
  /// \param _CapacityMap This read-only EdgeMap determines the capacities of 
  /// the edges. It is read once for each edge, so the map may involve in
  /// relatively time consuming process to compute the edge capacity if
  /// it is necessary. The default map type is \ref
  /// concepts::Graph::EdgeMap "Graph::EdgeMap<int>".  The value
  /// of CapacityMap is not used directly by search algorithm, it is only 
  /// passed to \ref MaxCardinalitySearchDefaultTraits.  
  /// \param _Traits Traits class to set various data types used by the 
  /// algorithm.  The default traits class is 
  /// \ref MaxCardinalitySearchDefaultTraits 
  /// "MaxCardinalitySearchDefaultTraits<_Graph, _CapacityMap>".  
  /// See \ref MaxCardinalitySearchDefaultTraits 
  /// for the documentation of a MaxCardinalitySearch traits class.
  ///
  /// \author Balazs Dezso

#ifdef DOXYGEN
  template <typename _Graph, typename _CapacityMap, typename _Traits>
#else
  template <typename _Graph = ListUGraph,
	    typename _CapacityMap = typename _Graph::template EdgeMap<int>,
	    typename _Traits = 
            MaxCardinalitySearchDefaultTraits<_Graph, _CapacityMap> >
#endif
  class MaxCardinalitySearch {
  public:
    /// \brief \ref Exception for uninitialized parameters.
    ///
    /// This error represents problems in the initialization
    /// of the parameters of the algorithms.
    class UninitializedParameter : public lemon::UninitializedParameter {
    public:
      virtual const char* what() const throw() {
	return "lemon::MaxCardinalitySearch::UninitializedParameter";
      }
    };

    typedef _Traits Traits;
    ///The type of the underlying graph.
    typedef typename Traits::Graph Graph;
    
    ///The type of the capacity of the edges.
    typedef typename Traits::CapacityMap::Value Value;
    ///The type of the map that stores the edge capacities.
    typedef typename Traits::CapacityMap CapacityMap;
    ///The type of the map indicating if a node is processed.
    typedef typename Traits::ProcessedMap ProcessedMap;
    ///The type of the map that stores the cardinalities of the nodes.
    typedef typename Traits::CardinalityMap CardinalityMap;
    ///The cross reference type used for the current heap.
    typedef typename Traits::HeapCrossRef HeapCrossRef;
    ///The heap type used by the algorithm. It maximize the priorities.
    typedef typename Traits::Heap Heap;
  private:
    /// Pointer to the underlying graph.
    const Graph *_graph;
    /// Pointer to the capacity map
    const CapacityMap *_capacity;
    ///Pointer to the map of cardinality.
    CardinalityMap *_cardinality;
    ///Indicates if \ref _cardinality is locally allocated (\c true) or not.
    bool local_cardinality;
    ///Pointer to the map of processed status of the nodes.
    ProcessedMap *_processed;
    ///Indicates if \ref _processed is locally allocated (\c true) or not.
    bool local_processed;
    ///Pointer to the heap cross references.
    HeapCrossRef *_heap_cross_ref;
    ///Indicates if \ref _heap_cross_ref is locally allocated (\c true) or not.
    bool local_heap_cross_ref;
    ///Pointer to the heap.
    Heap *_heap;
    ///Indicates if \ref _heap is locally allocated (\c true) or not.
    bool local_heap;

  public :

    typedef MaxCardinalitySearch Create;
 
    ///\name Named template parameters

    ///@{

    template <class T>
    struct DefCardinalityMapTraits : public Traits {
      typedef T CardinalityMap;
      static CardinalityMap *createCardinalityMap(const Graph &) 
      {
	throw UninitializedParameter();
      }
    };
    /// \brief \ref named-templ-param "Named parameter" for setting 
    /// CardinalityMap type
    ///
    /// \ref named-templ-param "Named parameter" for setting CardinalityMap 
    /// type
    template <class T>
    struct DefCardinalityMap 
      : public MaxCardinalitySearch<Graph, CapacityMap, 
                                    DefCardinalityMapTraits<T> > { 
      typedef MaxCardinalitySearch<Graph, CapacityMap, 
                                   DefCardinalityMapTraits<T> > Create;
    };
    
    template <class T>
    struct DefProcessedMapTraits : public Traits {
      typedef T ProcessedMap;
      static ProcessedMap *createProcessedMap(const Graph &) {
	throw UninitializedParameter();
      }
    };
    /// \brief \ref named-templ-param "Named parameter" for setting 
    /// ProcessedMap type
    ///
    /// \ref named-templ-param "Named parameter" for setting ProcessedMap type
    ///
    template <class T>
    struct DefProcessedMap 
      : public MaxCardinalitySearch<Graph, CapacityMap, 
                                    DefProcessedMapTraits<T> > { 
      typedef MaxCardinalitySearch<Graph, CapacityMap, 
                                   DefProcessedMapTraits<T> > Create;
    };
    
    template <class H, class CR>
    struct DefHeapTraits : public Traits {
      typedef CR HeapCrossRef;
      typedef H Heap;
      static HeapCrossRef *createHeapCrossRef(const Graph &) {
	throw UninitializedParameter();
      }
      static Heap *createHeap(HeapCrossRef &) {
	throw UninitializedParameter();
      }
    };
    /// \brief \ref named-templ-param "Named parameter" for setting heap 
    /// and cross reference type
    ///
    /// \ref named-templ-param "Named parameter" for setting heap and cross 
    /// reference type
    template <class H, class CR = typename Graph::template NodeMap<int> >
    struct DefHeap
      : public MaxCardinalitySearch<Graph, CapacityMap, 
                                    DefHeapTraits<H, CR> > { 
      typedef MaxCardinalitySearch< Graph, CapacityMap, 
                                    DefHeapTraits<H, CR> > Create;
    };

    template <class H, class CR>
    struct DefStandardHeapTraits : public Traits {
      typedef CR HeapCrossRef;
      typedef H Heap;
      static HeapCrossRef *createHeapCrossRef(const Graph &graph) {
	return new HeapCrossRef(graph);
      }
      static Heap *createHeap(HeapCrossRef &crossref) {
	return new Heap(crossref);
      }
    };

    /// \brief \ref named-templ-param "Named parameter" for setting heap and 
    /// cross reference type with automatic allocation
    ///
    /// \ref named-templ-param "Named parameter" for setting heap and cross 
    /// reference type. It can allocate the heap and the cross reference 
    /// object if the cross reference's constructor waits for the graph as 
    /// parameter and the heap's constructor waits for the cross reference.
    template <class H, class CR = typename Graph::template NodeMap<int> >
    struct DefStandardHeap
      : public MaxCardinalitySearch<Graph, CapacityMap, 
                                    DefStandardHeapTraits<H, CR> > { 
      typedef MaxCardinalitySearch<Graph, CapacityMap, 
                                   DefStandardHeapTraits<H, CR> > 
      Create;
    };
    
    ///@}


  protected:

    MaxCardinalitySearch() {}

  public:      
    
    /// \brief Constructor.
    ///
    ///\param graph the graph the algorithm will run on.
    ///\param capacity the capacity map used by the algorithm.
    MaxCardinalitySearch(const Graph& graph, const CapacityMap& capacity) :
      _graph(&graph), _capacity(&capacity),
      _cardinality(0), local_cardinality(false),
      _processed(0), local_processed(false),
      _heap_cross_ref(0), local_heap_cross_ref(false),
      _heap(0), local_heap(false)
    { }
    
    /// \brief Destructor.
    ~MaxCardinalitySearch() {
      if(local_cardinality) delete _cardinality;
      if(local_processed) delete _processed;
      if(local_heap_cross_ref) delete _heap_cross_ref;
      if(local_heap) delete _heap;
    }

    /// \brief Sets the capacity map.
    ///
    /// Sets the capacity map.
    /// \return <tt> (*this) </tt>
    MaxCardinalitySearch &capacityMap(const CapacityMap &m) {
      _capacity = &m;
      return *this;
    }

    /// \brief Sets the map storing the cardinalities calculated by the 
    /// algorithm.
    ///
    /// Sets the map storing the cardinalities calculated by the algorithm.
    /// If you don't use this function before calling \ref run(),
    /// it will allocate one. The destuctor deallocates this
    /// automatically allocated map, of course.
    /// \return <tt> (*this) </tt>
    MaxCardinalitySearch &cardinalityMap(CardinalityMap &m) {
      if(local_cardinality) {
	delete _cardinality;
	local_cardinality=false;
      }
      _cardinality = &m;
      return *this;
    }

    /// \brief Sets the map storing the processed nodes.
    ///
    /// Sets the map storing the processed nodes.
    /// If you don't use this function before calling \ref run(),
    /// it will allocate one. The destuctor deallocates this
    /// automatically allocated map, of course.
    /// \return <tt> (*this) </tt>
    MaxCardinalitySearch &processedMap(ProcessedMap &m) 
    {
      if(local_processed) {
	delete _processed;
	local_processed=false;
      }
      _processed = &m;
      return *this;
    }

    /// \brief Sets the heap and the cross reference used by algorithm.
    ///
    /// Sets the heap and the cross reference used by algorithm.
    /// If you don't use this function before calling \ref run(),
    /// it will allocate one. The destuctor deallocates this
    /// automatically allocated map, of course.
    /// \return <tt> (*this) </tt>
    MaxCardinalitySearch &heap(Heap& hp, HeapCrossRef &cr) {
      if(local_heap_cross_ref) {
	delete _heap_cross_ref;
	local_heap_cross_ref = false;
      }
      _heap_cross_ref = &cr;
      if(local_heap) {
	delete _heap;
	local_heap = false;
      }
      _heap = &hp;
      return *this;
    }

  private:

    typedef typename Graph::Node Node;
    typedef typename Graph::NodeIt NodeIt;
    typedef typename Graph::Edge Edge;
    typedef typename Graph::InEdgeIt InEdgeIt;

    void create_maps() {
      if(!_cardinality) {
	local_cardinality = true;
	_cardinality = Traits::createCardinalityMap(*_graph);
      }
      if(!_processed) {
	local_processed = true;
	_processed = Traits::createProcessedMap(*_graph);
      }
      if (!_heap_cross_ref) {
	local_heap_cross_ref = true;
	_heap_cross_ref = Traits::createHeapCrossRef(*_graph);
      }
      if (!_heap) {
	local_heap = true;
	_heap = Traits::createHeap(*_heap_cross_ref);
      }
    }
    
    void finalizeNodeData(Node node, Value capacity) {
      _processed->set(node, true);
      _cardinality->set(node, capacity);
    }

  public:
    /// \name Execution control
    /// The simplest way to execute the algorithm is to use
    /// one of the member functions called \c run(...).
    /// \n
    /// If you need more control on the execution,
    /// first you must call \ref init(), then you can add several source nodes
    /// with \ref addSource().
    /// Finally \ref start() will perform the actual path
    /// computation.

    ///@{

    /// \brief Initializes the internal data structures.
    ///
    /// Initializes the internal data structures.
    void init() {
      create_maps();
      _heap->clear();
      for (NodeIt it(*_graph) ; it != INVALID ; ++it) {
	_processed->set(it, false);
	_heap_cross_ref->set(it, Heap::PRE_HEAP);
      }
    }
    
    /// \brief Adds a new source node.
    /// 
    /// Adds a new source node to the priority heap.
    ///
    /// It checks if the node has not yet been added to the heap.
    void addSource(Node source, Value capacity = 0) {
      if(_heap->state(source) == Heap::PRE_HEAP) {
	_heap->push(source, capacity);
      } 
    }
    
    /// \brief Processes the next node in the priority heap
    ///
    /// Processes the next node in the priority heap.
    ///
    /// \return The processed node.
    ///
    /// \warning The priority heap must not be empty!
    Node processNextNode() {
      Node node = _heap->top(); 
      finalizeNodeData(node, _heap->prio());
      _heap->pop();
      
      for (InEdgeIt it(*_graph, node); it != INVALID; ++it) {
	Node source = _graph->source(it); 
	switch (_heap->state(source)) {
	case Heap::PRE_HEAP:
	  _heap->push(source, (*_capacity)[it]); 
	  break;
	case Heap::IN_HEAP:
	  _heap->decrease(source, (*_heap)[source] + (*_capacity)[it]); 
	  break;
	case Heap::POST_HEAP:
	  break;
	}
      }
      return node;
    }

    /// \brief Next node to be processed.
    ///
    /// Next node to be processed.
    ///
    /// \return The next node to be processed or INVALID if the 
    /// priority heap is empty.
    Node nextNode() { 
      return _heap->empty() ? _heap->top() : INVALID;
    }
 
    /// \brief Returns \c false if there are nodes
    /// to be processed in the priority heap
    ///
    /// Returns \c false if there are nodes
    /// to be processed in the priority heap
    bool emptyQueue() { return _heap->empty(); }
    /// \brief Returns the number of the nodes to be processed 
    /// in the priority heap
    ///
    /// Returns the number of the nodes to be processed in the priority heap
    int queueSize() { return _heap->size(); }
    
    /// \brief Executes the algorithm.
    ///
    /// Executes the algorithm.
    ///
    ///\pre init() must be called and at least one node should be added
    /// with addSource() before using this function.
    ///
    /// This method runs the Maximum Cardinality Search algorithm from the 
    /// source node(s).
    void start() {
      while ( !_heap->empty() ) processNextNode();
    }
    
    /// \brief Executes the algorithm until \c dest is reached.
    ///
    /// Executes the algorithm until \c dest is reached.
    ///
    /// \pre init() must be called and at least one node should be added
    /// with addSource() before using this function.
    ///
    /// This method runs the %MaxCardinalitySearch algorithm from the source 
    /// nodes.
    void start(Node dest) {
      while ( !_heap->empty() && _heap->top()!=dest ) processNextNode();
      if ( !_heap->empty() ) finalizeNodeData(_heap->top(), _heap->prio());
    }
    
    /// \brief Executes the algorithm until a condition is met.
    ///
    /// Executes the algorithm until a condition is met.
    ///
    /// \pre init() must be called and at least one node should be added
    /// with addSource() before using this function.
    ///
    /// \param nm must be a bool (or convertible) node map. The algorithm
    /// will stop when it reaches a node \c v with <tt>nm[v]==true</tt>.
    template <typename NodeBoolMap>
    void start(const NodeBoolMap &nm) {
      while ( !_heap->empty() && !nm[_heap->top()] ) processNextNode();
      if ( !_heap->empty() ) finalizeNodeData(_heap->top(),_heap->prio());
    }
    
    /// \brief Runs the maximal cardinality search algorithm from node \c s.
    ///
    /// This method runs the %MaxCardinalitySearch algorithm from a root 
    /// node \c s.
    ///
    ///\note d.run(s) is just a shortcut of the following code.
    ///\code
    ///  d.init();
    ///  d.addSource(s);
    ///  d.start();
    ///\endcode
    void run(Node s) {
      init();
      addSource(s);
      start();
    }

    /// \brief Runs the maximal cardinality search algorithm for the 
    /// whole graph.
    ///
    /// This method runs the %MaxCardinalitySearch algorithm from all 
    /// unprocessed node of the graph.
    ///
    ///\note d.run(s) is just a shortcut of the following code.
    ///\code
    ///  d.init();
    ///  for (NodeIt it(graph); it != INVALID; ++it) {
    ///    if (!d.reached(it)) {
    ///      d.addSource(s);
    ///      d.start();
    ///    }
    ///  }
    ///\endcode
    void run() {
      init();
      for (NodeIt it(*_graph); it != INVALID; ++it) {
        if (!reached(it)) {
          addSource(it);
          start();
        }
      }
    }
    
    ///@}

    /// \name Query Functions
    /// The result of the maximum cardinality search algorithm can be 
    /// obtained using these functions.
    /// \n
    /// Before the use of these functions, either run() or start() must be 
    /// called.
    
    ///@{

    /// \brief The cardinality of a node.
    ///
    /// Returns the cardinality of a node.
    /// \pre \ref run() must be called before using this function.
    /// \warning If node \c v in unreachable from the root the return value
    /// of this funcion is undefined.
    Value cardinality(Node node) const { return (*_cardinality)[node]; }

    /// \brief The current cardinality of a node.
    ///
    /// Returns the current cardinality of a node.
    /// \pre the given node should be reached but not processed
    Value currentCardinality(Node node) const { return (*_heap)[node]; }

    /// \brief Returns a reference to the NodeMap of cardinalities.
    ///
    /// Returns a reference to the NodeMap of cardinalities. \pre \ref run() 
    /// must be called before using this function.
    const CardinalityMap &cardinalityMap() const { return *_cardinality;}
 
    /// \brief Checks if a node is reachable from the root.
    ///
    /// Returns \c true if \c v is reachable from the root.
    /// \warning The source nodes are inditated as unreached.
    /// \pre \ref run() must be called before using this function.
    bool reached(Node v) { return (*_heap_cross_ref)[v] != Heap::PRE_HEAP; }

    /// \brief Checks if a node is processed.
    ///
    /// Returns \c true if \c v is processed, i.e. the shortest
    /// path to \c v has already found.
    /// \pre \ref run() must be called before using this function.
    bool processed(Node v) { return (*_heap_cross_ref)[v] == Heap::POST_HEAP; }
    
    ///@}
  };

  /// \brief Default traits class of NagamochiIbaraki class.
  ///
  /// Default traits class of NagamochiIbaraki class.
  /// \param Graph Graph type.
  /// \param CapacityMap Type of length map.
  template <typename _Graph, typename _CapacityMap>
  struct NagamochiIbarakiDefaultTraits {
    /// \brief The type of the capacity of the edges.
    typedef typename _CapacityMap::Value Value;

    /// The graph type the algorithm runs on. 
    typedef _Graph Graph;

    /// The AuxGraph type which is an Graph
    typedef ListUGraph AuxGraph;

    /// \brief Instantiates a AuxGraph.
    ///
    /// This function instantiates a \ref AuxGraph. 
    static AuxGraph *createAuxGraph() {
      return new AuxGraph();
    }

    /// \brief The type of the map that stores the edge capacities.
    ///
    /// The type of the map that stores the edge capacities.
    /// It must meet the \ref concepts::ReadMap "ReadMap" concept.
    typedef _CapacityMap CapacityMap;

    /// \brief Instantiates a CapacityMap.
    ///
    /// This function instantiates a \ref CapacityMap.
#ifdef DOXYGEN
    static CapacityMap *createCapacityMap(const Graph& graph) 
#else
    static CapacityMap *createCapacityMap(const Graph&)
#endif
    {
      throw UninitializedParameter();
    }

    /// \brief The CutValueMap type
    ///
    /// The type of the map that stores the cut value of a node.
    typedef AuxGraph::NodeMap<Value> AuxCutValueMap;

    /// \brief Instantiates a AuxCutValueMap.
    ///
    /// This function instantiates a \ref AuxCutValueMap. 
    static AuxCutValueMap *createAuxCutValueMap(const AuxGraph& graph) {
      return new AuxCutValueMap(graph);
    }

    /// \brief The AuxCapacityMap type
    ///
    /// The type of the map that stores the auxiliary edge capacities.
    typedef AuxGraph::UEdgeMap<Value> AuxCapacityMap;

    /// \brief Instantiates a AuxCapacityMap.
    ///
    /// This function instantiates a \ref AuxCapacityMap. 
    static AuxCapacityMap *createAuxCapacityMap(const AuxGraph& graph) {
      return new AuxCapacityMap(graph);
    }

    /// \brief The cross reference type used by heap.
    ///
    /// The cross reference type used by heap.
    /// Usually it is \c Graph::NodeMap<int>.
    typedef AuxGraph::NodeMap<int> HeapCrossRef;

    /// \brief Instantiates a HeapCrossRef.
    ///
    /// This function instantiates a \ref HeapCrossRef. 
    /// \param graph is the graph, to which we would like to define the 
    /// HeapCrossRef.
    static HeapCrossRef *createHeapCrossRef(const AuxGraph &graph) {
      return new HeapCrossRef(graph);
    }
    
    /// \brief The heap type used by NagamochiIbaraki algorithm.
    ///
    /// The heap type used by NagamochiIbaraki algorithm. It should
    /// maximalize the priorities and the heap's key type is
    /// the aux graph's node.
    ///
    /// \sa BinHeap
    /// \sa NagamochiIbaraki
    typedef typename _min_cut_bits
    ::HeapSelector<CapacityMap>
    ::template Selector<Value, HeapCrossRef>
    ::Heap Heap;
    
    /// \brief Instantiates a Heap.
    ///
    /// This function instantiates a \ref Heap. 
    /// \param crossref The cross reference of the heap.
    static Heap *createHeap(HeapCrossRef& crossref) {
      return new Heap(crossref);
    }

    /// \brief Map from the AuxGraph's node type to the Graph's node type.
    ///
    /// Map from the AuxGraph's node type to the Graph's node type.
    typedef typename AuxGraph
    ::template NodeMap<typename Graph::Node> NodeRefMap;

    /// \brief Instantiates a NodeRefMap.
    ///
    /// This function instantiates a \ref NodeRefMap. 
    static NodeRefMap *createNodeRefMap(const AuxGraph& graph) {
      return new NodeRefMap(graph);
    }

    /// \brief Map from the Graph's node type to the Graph's node type.
    ///
    /// Map from the Graph's node type to the Graph's node type.
    typedef typename Graph
    ::template NodeMap<typename Graph::Node> ListRefMap;

    /// \brief Instantiates a ListRefMap.
    ///
    /// This function instantiates a \ref ListRefMap. 
    static ListRefMap *createListRefMap(const Graph& graph) {
      return new ListRefMap(graph);
    }
    

  };

  /// \ingroup min_cut
  ///
  /// \brief Calculates the minimum cut in an undirected graph.
  ///
  /// Calculates the minimum cut in an undirected graph with the
  /// Nagamochi-Ibaraki algorithm. The algorithm separates the graph's
  /// nodes into two partitions with the minimum sum of edge capacities
  /// between the two partitions. The algorithm can be used to test
  /// the network reliability specifically to test how many links have
  /// to be destroyed in the network to split it at least two
  /// distinict subnetwork.
  ///
  /// The complexity of the algorithm is \f$ O(ne\log(n)) \f$ but with
  /// Fibonacci heap it can be decreased to \f$ O(ne+n^2\log(n)) \f$.
  /// When unit capacity minimum cut is computed then it uses
  /// BucketHeap which results \f$ O(ne) \f$ time complexity.
  ///
  /// \warning The value type of the capacity map should be able to hold
  /// any cut value of the graph, otherwise the result can overflow.
#ifdef DOXYGEN
  template <typename _Graph, typename _CapacityMap, typename _Traits>
#else
  template <typename _Graph = ListUGraph, 
	    typename _CapacityMap = typename _Graph::template UEdgeMap<int>, 
	    typename _Traits 
            = NagamochiIbarakiDefaultTraits<_Graph, _CapacityMap> >
#endif
  class NagamochiIbaraki {
  public:
    /// \brief \ref Exception for uninitialized parameters.
    ///
    /// This error represents problems in the initialization
    /// of the parameters of the algorithms.
    class UninitializedParameter : public lemon::UninitializedParameter {
    public:
      virtual const char* what() const throw() {
	return "lemon::NagamochiIbaraki::UninitializedParameter";
      }
    };


  private:

    typedef _Traits Traits;
    /// The type of the underlying graph.
    typedef typename Traits::Graph Graph;
    
    /// The type of the capacity of the edges.
    typedef typename Traits::CapacityMap::Value Value;
    /// The type of the map that stores the edge capacities.
    typedef typename Traits::CapacityMap CapacityMap;
    /// The type of the aux graph
    typedef typename Traits::AuxGraph AuxGraph;
    /// The type of the aux capacity map
    typedef typename Traits::AuxCapacityMap AuxCapacityMap;
    /// The type of the aux cut value map
    typedef typename Traits::AuxCutValueMap AuxCutValueMap;
    /// The cross reference type used for the current heap.
    typedef typename Traits::HeapCrossRef HeapCrossRef;
    /// The heap type used by the max cardinality algorithm.
    typedef typename Traits::Heap Heap;
    /// The node refrefernces between the original and aux graph type.
    typedef typename Traits::NodeRefMap NodeRefMap;
    /// The list node refrefernces in the original graph type.
    typedef typename Traits::ListRefMap ListRefMap;

  public:

    ///\name Named template parameters

    ///@{

    struct DefUnitCapacityTraits : public Traits {
      typedef ConstMap<typename Graph::UEdge, Const<int, 1> > CapacityMap;
      static CapacityMap *createCapacityMap(const Graph&) {
	return new CapacityMap();
      }
    };
    /// \brief \ref named-templ-param "Named parameter" for setting  
    /// the capacity type to constMap<UEdge, int, 1>()
    ///
    /// \ref named-templ-param "Named parameter" for setting 
    /// the capacity type to constMap<UEdge, int, 1>()
    struct DefUnitCapacity
      : public NagamochiIbaraki<Graph, CapacityMap, 
                                DefUnitCapacityTraits> { 
      typedef NagamochiIbaraki<Graph, CapacityMap, 
                               DefUnitCapacityTraits> Create;
    };


    template <class H, class CR>
    struct DefHeapTraits : public Traits {
      typedef CR HeapCrossRef;
      typedef H Heap;
      static HeapCrossRef *createHeapCrossRef(const AuxGraph &) {
	throw UninitializedParameter();
      }
      static Heap *createHeap(HeapCrossRef &) {
	throw UninitializedParameter();
      }
    };
    /// \brief \ref named-templ-param "Named parameter" for setting heap 
    /// and cross reference type
    ///
    /// \ref named-templ-param "Named parameter" for setting heap and cross 
    /// reference type
    template <class H, class CR = typename Graph::template NodeMap<int> >
    struct DefHeap
      : public NagamochiIbaraki<Graph, CapacityMap, 
                                DefHeapTraits<H, CR> > { 
      typedef NagamochiIbaraki< Graph, CapacityMap, 
                                DefHeapTraits<H, CR> > Create;
    };

    template <class H, class CR>
    struct DefStandardHeapTraits : public Traits {
      typedef CR HeapCrossRef;
      typedef H Heap;
      static HeapCrossRef *createHeapCrossRef(const AuxGraph &graph) {
	return new HeapCrossRef(graph);
      }
      static Heap *createHeap(HeapCrossRef &crossref) {
	return new Heap(crossref);
      }
    };

    /// \brief \ref named-templ-param "Named parameter" for setting heap and 
    /// cross reference type with automatic allocation
    ///
    /// \ref named-templ-param "Named parameter" for setting heap and cross 
    /// reference type. It can allocate the heap and the cross reference 
    /// object if the cross reference's constructor waits for the graph as 
    /// parameter and the heap's constructor waits for the cross reference.
    template <class H, class CR = typename Graph::template NodeMap<int> >
    struct DefStandardHeap
      : public NagamochiIbaraki<Graph, CapacityMap, 
                                DefStandardHeapTraits<H, CR> > { 
      typedef NagamochiIbaraki<Graph, CapacityMap, 
                               DefStandardHeapTraits<H, CR> > 
      Create;
    };

    ///@}


  private:
    /// Pointer to the underlying graph.
    const Graph *_graph;
    /// Pointer to the capacity map
    const CapacityMap *_capacity;
    /// \brief Indicates if \ref _capacity is locally allocated 
    /// (\c true) or not.
    bool local_capacity;

    /// Pointer to the aux graph.
    AuxGraph *_aux_graph;
    /// \brief Indicates if \ref _aux_graph is locally allocated 
    /// (\c true) or not.
    bool local_aux_graph;
    /// Pointer to the aux capacity map
    AuxCapacityMap *_aux_capacity;
    /// \brief Indicates if \ref _aux_capacity is locally allocated 
    /// (\c true) or not.
    bool local_aux_capacity;
    /// Pointer to the aux cut value map
    AuxCutValueMap *_aux_cut_value;
    /// \brief Indicates if \ref _aux_cut_value is locally allocated 
    /// (\c true) or not.
    bool local_aux_cut_value;
    /// Pointer to the heap cross references.
    HeapCrossRef *_heap_cross_ref;
    /// \brief Indicates if \ref _heap_cross_ref is locally allocated 
    /// (\c true) or not.
    bool local_heap_cross_ref;
    /// Pointer to the heap.
    Heap *_heap;
    /// Indicates if \ref _heap is locally allocated (\c true) or not.
    bool local_heap;

    /// The min cut value.
    Value _min_cut;
    /// The number of the nodes of the aux graph.
    int _node_num;
    /// The first and last node of the min cut in the next list.
    std::vector<typename Graph::Node> _cut;

    /// \brief The first and last element in the list associated
    /// to the aux graph node.
    NodeRefMap *_first, *_last;
    /// \brief The next node in the node lists.
    ListRefMap *_next;
    
    void createStructures() {
      if (!_capacity) {
        local_capacity = true;
        _capacity = Traits::createCapacityMap(*_graph);
      }
      if(!_aux_graph) {
	local_aux_graph = true;
	_aux_graph = Traits::createAuxGraph();
      }
      if(!_aux_capacity) {
	local_aux_capacity = true;
	_aux_capacity = Traits::createAuxCapacityMap(*_aux_graph);
      }
      if(!_aux_cut_value) {
	local_aux_cut_value = true;
	_aux_cut_value = Traits::createAuxCutValueMap(*_aux_graph);
      }

      _first = Traits::createNodeRefMap(*_aux_graph);
      _last = Traits::createNodeRefMap(*_aux_graph);

      _next = Traits::createListRefMap(*_graph);

      if (!_heap_cross_ref) {
	local_heap_cross_ref = true;
	_heap_cross_ref = Traits::createHeapCrossRef(*_aux_graph);
      }
      if (!_heap) {
	local_heap = true;
	_heap = Traits::createHeap(*_heap_cross_ref);
      }
    }

    void createAuxGraph() {
      typename Graph::template NodeMap<typename AuxGraph::Node> ref(*_graph);

      for (typename Graph::NodeIt n(*_graph); n != INVALID; ++n) {
        _next->set(n, INVALID);
        typename AuxGraph::Node node = _aux_graph->addNode();
        _first->set(node, n);
        _last->set(node, n);
        ref.set(n, node);
      }

      typename AuxGraph::template NodeMap<typename AuxGraph::UEdge> 
      edges(*_aux_graph, INVALID);

      for (typename Graph::NodeIt n(*_graph); n != INVALID; ++n) {
        for (typename Graph::IncEdgeIt e(*_graph, n); e != INVALID; ++e) {
          typename Graph::Node tn = _graph->runningNode(e);
          if (n < tn || n == tn) continue;
          if (edges[ref[tn]] != INVALID) {
            Value value = 
              (*_aux_capacity)[edges[ref[tn]]] + (*_capacity)[e];
            _aux_capacity->set(edges[ref[tn]], value);
          } else {
            edges.set(ref[tn], _aux_graph->addEdge(ref[n], ref[tn]));
            Value value = (*_capacity)[e];
            _aux_capacity->set(edges[ref[tn]], value);            
          }
        }
        for (typename Graph::IncEdgeIt e(*_graph, n); e != INVALID; ++e) {
          typename Graph::Node tn = _graph->runningNode(e);
          edges.set(ref[tn], INVALID);
        }
      }

      _cut.resize(1, INVALID);
      _min_cut = std::numeric_limits<Value>::max();
      for (typename AuxGraph::NodeIt n(*_aux_graph); n != INVALID; ++n) {
        Value value = 0;
        for (typename AuxGraph::IncEdgeIt e(*_aux_graph, n); 
             e != INVALID; ++e) {
          value += (*_aux_capacity)[e];
        }
        if (_min_cut > value) {
          _min_cut = value;
          _cut[0] = (*_first)[n];
        } 
        (*_aux_cut_value)[n] = value;
      }
    }
    

  public :

    typedef NagamochiIbaraki Create;


    /// \brief Constructor.
    ///
    ///\param graph the graph the algorithm will run on.
    ///\param capacity the capacity map used by the algorithm.
    NagamochiIbaraki(const Graph& graph, const CapacityMap& capacity) 
      : _graph(&graph), 
        _capacity(&capacity), local_capacity(false),
        _aux_graph(0), local_aux_graph(false),
        _aux_capacity(0), local_aux_capacity(false),
        _aux_cut_value(0), local_aux_cut_value(false),
        _heap_cross_ref(0), local_heap_cross_ref(false),
        _heap(0), local_heap(false),
        _first(0), _last(0), _next(0) {}

    /// \brief Constructor.
    ///
    /// This constructor can be used only when the Traits class
    /// defines how can we instantiate a local capacity map.
    /// If the DefUnitCapacity used the algorithm automatically
    /// construct the capacity map.
    ///
    ///\param graph the graph the algorithm will run on.
    NagamochiIbaraki(const Graph& graph) 
      : _graph(&graph), 
        _capacity(0), local_capacity(false),
        _aux_graph(0), local_aux_graph(false),
        _aux_capacity(0), local_aux_capacity(false),
        _aux_cut_value(0), local_aux_cut_value(false),
        _heap_cross_ref(0), local_heap_cross_ref(false),
        _heap(0), local_heap(false),
        _first(0), _last(0), _next(0) {}

    /// \brief Destructor.
    ///
    /// Destructor.
    ~NagamochiIbaraki() {
      if (local_heap) delete _heap;
      if (local_heap_cross_ref) delete _heap_cross_ref;
      if (_first) delete _first;
      if (_last) delete _last;
      if (_next) delete _next;
      if (local_aux_capacity) delete _aux_capacity;
      if (local_aux_cut_value) delete _aux_cut_value;
      if (local_aux_graph) delete _aux_graph;
      if (local_capacity) delete _capacity;
    }

    /// \brief Sets the heap and the cross reference used by algorithm.
    ///
    /// Sets the heap and the cross reference used by algorithm.
    /// If you don't use this function before calling \ref run(),
    /// it will allocate one. The destuctor deallocates this
    /// automatically allocated heap and cross reference, of course.
    /// \return <tt> (*this) </tt>
    NagamochiIbaraki &heap(Heap& hp, HeapCrossRef &cr)
    {
      if (local_heap_cross_ref) {
	delete _heap_cross_ref;
	local_heap_cross_ref=false;
      }
      _heap_cross_ref = &cr;
      if (local_heap) {
	delete _heap;
	local_heap=false;
      }
      _heap = &hp;
      return *this;
    }

    /// \brief Sets the aux graph.
    ///
    /// Sets the aux graph used by algorithm.
    /// If you don't use this function before calling \ref run(),
    /// it will allocate one. The destuctor deallocates this
    /// automatically allocated graph, of course.
    /// \return <tt> (*this) </tt>
    NagamochiIbaraki &auxGraph(AuxGraph& aux_graph)
    {
      if(local_aux_graph) {
	delete _aux_graph;
	local_aux_graph=false;
      }
      _aux_graph = &aux_graph;
      return *this;
    }

    /// \brief Sets the aux capacity map.
    ///
    /// Sets the aux capacity map used by algorithm.
    /// If you don't use this function before calling \ref run(),
    /// it will allocate one. The destuctor deallocates this
    /// automatically allocated graph, of course.
    /// \return <tt> (*this) </tt>
    NagamochiIbaraki &auxCapacityMap(AuxCapacityMap& aux_capacity_map)
    {
      if(local_aux_capacity) {
	delete _aux_capacity;
	local_aux_capacity=false;
      }
      _aux_capacity = &aux_capacity_map;
      return *this;
    }

    /// \name Execution control
    /// The simplest way to execute the algorithm is to use
    /// one of the member functions called \c run().
    /// \n
    /// If you need more control on the execution,
    /// first you must call \ref init() and then call the start()
    /// or proper times the processNextPhase() member functions.

    ///@{

    /// \brief Initializes the internal data structures.
    ///
    /// Initializes the internal data structures.
    void init() {
      _node_num = countNodes(*_graph);
      createStructures();
      createAuxGraph();
    }

  private:

    struct EdgeInfo {
      typename AuxGraph::Node source, target;
      Value capacity;
    };
    
    struct EdgeInfoLess {
      bool operator()(const EdgeInfo& left, const EdgeInfo& right) const {
        return (left.source < right.source) || 
          (left.source == right.source && left.target < right.target);
      }
    };

  public:


    /// \brief Processes the next phase
    ///
    /// Processes the next phase in the algorithm. The function should
    /// be called at most countNodes(graph) - 1 times to get surely
    /// the min cut in the graph.
    ///
    ///\return %True when the algorithm finished.
    bool processNextPhase() {
      if (_node_num <= 1) return true;

      typedef typename AuxGraph::Node Node;
      typedef typename AuxGraph::NodeIt NodeIt;
      typedef typename AuxGraph::UEdge UEdge;
      typedef typename AuxGraph::UEdgeIt UEdgeIt;
      typedef typename AuxGraph::IncEdgeIt IncEdgeIt;
      
      typename AuxGraph::template UEdgeMap<Value> _edge_cut(*_aux_graph);


      for (NodeIt n(*_aux_graph); n != INVALID; ++n) {
        _heap_cross_ref->set(n, Heap::PRE_HEAP);
      }

      std::vector<Node> nodes;
      nodes.reserve(_node_num);
      int sep = 0;

      Value alpha = 0;
      Value emc = std::numeric_limits<Value>::max();

      _heap->push(typename AuxGraph::NodeIt(*_aux_graph), 0);
      while (!_heap->empty()) {
        Node node = _heap->top();
        Value value = _heap->prio();
        
        _heap->pop();
        for (typename AuxGraph::IncEdgeIt e(*_aux_graph, node); 
             e != INVALID; ++e) {
          Node tn = _aux_graph->runningNode(e);
          switch (_heap->state(tn)) {
          case Heap::PRE_HEAP:
            _heap->push(tn, (*_aux_capacity)[e]);
            _edge_cut[e] = (*_heap)[tn];
            break;
          case Heap::IN_HEAP:
            _heap->decrease(tn, (*_aux_capacity)[e] + (*_heap)[tn]);
            _edge_cut[e] = (*_heap)[tn];
            break;
          case Heap::POST_HEAP:
            break;
          }
        }

        alpha += (*_aux_cut_value)[node];
        alpha -= 2 * value;

        nodes.push_back(node);
        if (!_heap->empty()) {
          if (alpha < emc) {
            emc = alpha;
            sep = nodes.size();
          }
        }
      }

      if (int(nodes.size()) < _node_num) {
        _aux_graph->clear();
        _node_num = 1;
        _cut.clear();
        for (int i = 0; i < int(nodes.size()); ++i) {
          typename Graph::Node n = (*_first)[nodes[i]];
          while (n != INVALID) {
            _cut.push_back(n);
            n = (*_next)[n];
          }
        }
        _min_cut = 0;
        return true;
      }

      if (emc < _min_cut) {
        _cut.clear();
        for (int i = 0; i < sep; ++i) {
          typename Graph::Node n = (*_first)[nodes[i]];
          while (n != INVALID) {
            _cut.push_back(n);
            n = (*_next)[n];
          }
        }
        _min_cut = emc;
      }

      typedef typename AuxGraph::template NodeMap<int> UfeCr;
      UfeCr ufecr(*_aux_graph);
      typedef UnionFindEnum<UfeCr> Ufe; 
      Ufe ufe(ufecr);

      for (typename AuxGraph::NodeIt n(*_aux_graph); n != INVALID; ++n) {
        ufe.insert(n);
      }

      for (typename AuxGraph::UEdgeIt e(*_aux_graph); e != INVALID; ++e) {
        if (_edge_cut[e] >= emc) {
          ufe.join(_aux_graph->source(e), _aux_graph->target(e));
        }
      }

      typedef typename Ufe::ClassIt UfeCIt;
      if (ufe.size(UfeCIt(ufe)) == _node_num) {
        _aux_graph->clear();
        _node_num = 1;
        return true;
      }
      
      std::vector<typename AuxGraph::Node> remnodes;

      typename AuxGraph::template NodeMap<UEdge> edges(*_aux_graph, INVALID);
      for (typename Ufe::ClassIt c(ufe); c != INVALID; ++c) {
        if (ufe.size(c) == 1) continue;
	Node cn = ufe.item(c);
        for (typename Ufe::ItemIt r(ufe, c); r != INVALID; ++r) {
          if (static_cast<Node>(r) == static_cast<Node>(cn)) continue;
          _next->set((*_last)[cn], (*_first)[r]);
          _last->set(cn, (*_last)[r]);
          remnodes.push_back(r);
          --_node_num;
        }
      }

      std::vector<EdgeInfo> addedges;
      std::vector<UEdge> remedges;

      for (typename AuxGraph::UEdgeIt e(*_aux_graph);
           e != INVALID; ++e) {
	int sc = ufe.find(_aux_graph->source(e));
	int tc = ufe.find(_aux_graph->target(e));
        if ((ufe.size(sc) == 1 && ufe.size(tc) == 1)) {
          continue;
        }
        if (sc == tc) {
          remedges.push_back(e);
          continue;
        }
        Node sn = ufe.item(sc);
        Node tn = ufe.item(tc);

        EdgeInfo info;
        if (sn < tn) {
          info.source = sn;
          info.target = tn;
        } else {
          info.source = tn;
          info.target = sn;
        }
        info.capacity = (*_aux_capacity)[e];
        addedges.push_back(info);
        remedges.push_back(e);
      }

      for (int i = 0; i < int(remedges.size()); ++i) {
        _aux_graph->erase(remedges[i]);
      }

      sort(addedges.begin(), addedges.end(), EdgeInfoLess());

      {
        int i = 0;
        while (i < int(addedges.size())) {
          Node sn = addedges[i].source;
          Node tn = addedges[i].target;
          Value ec = addedges[i].capacity;
          ++i;
          while (i < int(addedges.size()) && 
                 sn == addedges[i].source && tn == addedges[i].target) {
            ec += addedges[i].capacity;
            ++i;
          }
          typename AuxGraph::UEdge ne = _aux_graph->addEdge(sn, tn);
          (*_aux_capacity)[ne] = ec;
        }
      }

      for (typename Ufe::ClassIt c(ufe); c != INVALID; ++c) {
        if (ufe.size(c) == 1) continue;
	Node cn = ufe.item(c);
        Value cutvalue = 0;
        for (typename AuxGraph::IncEdgeIt e(*_aux_graph, cn);
             e != INVALID; ++e) {
          cutvalue += (*_aux_capacity)[e];
        }
        
        (*_aux_cut_value)[cn] = cutvalue;
        
      }

      for (int i = 0; i < int(remnodes.size()); ++i) {
        _aux_graph->erase(remnodes[i]);
      }

      return _node_num == 1;
    }

    /// \brief Executes the algorithm.
    ///
    /// Executes the algorithm.
    ///
    /// \pre init() must be called
    void start() {
      while (!processNextPhase());
    }


    /// \brief Runs %NagamochiIbaraki algorithm.
    ///
    /// This method runs the %Min cut algorithm
    ///
    /// \note mc.run(s) is just a shortcut of the following code.
    ///\code
    ///  mc.init();
    ///  mc.start();
    ///\endcode
    void run() {
      init();
      start();
    }

    ///@}

    /// \name Query Functions 
    ///
    /// The result of the %NagamochiIbaraki
    /// algorithm can be obtained using these functions.\n 
    /// Before the use of these functions, either run() or start()
    /// must be called.
    
    ///@{

    /// \brief Returns the min cut value.
    ///
    /// Returns the min cut value if the algorithm finished.
    /// After the first processNextPhase() it is a value of a
    /// valid cut in the graph.
    Value minCut() const {
      return _min_cut;
    }

    /// \brief Returns a min cut in a NodeMap.
    ///
    /// It sets the nodes of one of the two partitions to true in
    /// the given BoolNodeMap. The map contains a valid cut if the
    /// map have been set false previously. 
    template <typename NodeMap>
    Value quickMinCut(NodeMap& nodeMap) const { 
      for (int i = 0; i < int(_cut.size()); ++i) {
        nodeMap.set(_cut[i], true);
      }
      return minCut();
    }

    /// \brief Returns a min cut in a NodeMap.
    ///
    /// It sets the nodes of one of the two partitions to true and
    /// the other partition to false. The function first set all of the
    /// nodes to false and after it call the quickMinCut() member.
    template <typename NodeMap>
    Value minCut(NodeMap& nodeMap) const { 
      for (typename Graph::NodeIt it(*_graph); it != INVALID; ++it) {
        nodeMap.set(it, false);      
      }
      quickMinCut(nodeMap);
      return minCut();
    }

    /// \brief Returns a min cut in an EdgeMap.
    ///
    /// If an undirected edge is in a min cut then it will be
    /// set to true and the others will be set to false in the given map.
    template <typename EdgeMap>
    Value cutEdges(EdgeMap& edgeMap) const {
      typename Graph::template NodeMap<bool> cut(*_graph, false);
      quickMinCut(cut);
      for (typename Graph::EdgeIt it(*_graph); it != INVALID; ++it) {
        edgeMap.set(it, cut[_graph->source(it)] ^ cut[_graph->target(it)]);
      }
      return minCut();
    }

    ///@}

  private:


  };
}

#endif