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

  *

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

  *

  * Copyright (C) 2003-2010

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

 #define LEMON_MIN_COST_ARBORESCENCE_H

 ///\ingroup spantree

 ///\file

 ///\brief Minimum Cost Arborescence algorithm.

 #include <vector>

 #include <lemon/list_graph.h>

 #include <lemon/bin_heap.h>

 #include <lemon/assert.h>

 namespace lemon {

   /// \brief Default traits class for MinCostArborescence class.

   ///

   /// Default traits class for MinCostArborescence class.

   /// \param GR Digraph type.

   /// \param CM Type of the cost map.

   template <class GR, class CM>

   struct MinCostArborescenceDefaultTraits{

     /// \brief The digraph type the algorithm runs on.

     typedef GR Digraph;

     /// \brief The type of the map that stores the arc costs.

     ///

     /// The type of the map that stores the arc costs.

     /// It must conform to the \ref concepts::ReadMap "ReadMap" concept.

     typedef CM CostMap;

     /// \brief The value type of the costs.

     ///

     /// The value type of the costs.

     typedef typename CostMap::Value Value;

     /// \brief The type of the map that stores which arcs are in the

     /// arborescence.

     ///

     /// The type of the map that stores which arcs are in the

     /// arborescence.  It must conform to the \ref concepts::WriteMap

     /// "WriteMap" concept, and its value type must be \c bool

     /// (or convertible). Initially it will be set to \c false on each

     /// arc, then it will be set on each arborescence arc once.

     typedef typename Digraph::template ArcMap<bool> ArborescenceMap;

     /// \brief Instantiates a \c ArborescenceMap.

     ///

     /// This function instantiates a \c ArborescenceMap.

     /// \param digraph The digraph to which we would like to calculate

     /// the \c ArborescenceMap.

     static ArborescenceMap *createArborescenceMap(const Digraph &digraph){

       return new ArborescenceMap(digraph);

     }

     /// \brief The type of the \c PredMap

     ///

     /// The type of the \c PredMap. It must confrom to the

     /// \ref concepts::WriteMap "WriteMap" concept, and its value type

     /// must be the \c Arc type of the digraph.

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

     /// \brief Instantiates a \c PredMap.

     ///

     /// This function instantiates a \c PredMap.

     /// \param digraph The digraph to which we would like to define the

     /// \c PredMap.

     static PredMap *createPredMap(const Digraph &digraph){

       return new PredMap(digraph);

     }

   };

   /// \ingroup spantree

   ///

   /// \brief Minimum Cost Arborescence algorithm class.

   ///

   /// This class provides an efficient implementation of the

   /// Minimum Cost Arborescence algorithm. The arborescence is a tree

   /// which is directed from a given source node of the digraph. One or

   /// more sources should be given to the algorithm and it will calculate

   /// the minimum cost subgraph that is the union of arborescences with the

   /// given sources and spans all the nodes which are reachable from the

   /// sources. The time complexity of the algorithm is O(n<sup>2</sup>+m).

   ///

   /// The algorithm also provides an optimal dual solution, therefore

   /// the optimality of the solution can be checked.

   ///

   /// \param GR The digraph type the algorithm runs on.

   /// \param CM A read-only arc map storing the costs of the

   /// arcs. It is read once for each arc, so the map may involve in

   /// relatively time consuming process to compute the arc costs if

   /// it is necessary. The default map type is \ref

   /// concepts::Digraph::ArcMap "Digraph::ArcMap<int>".

   /// \tparam TR The traits class that defines various types used by the

   /// algorithm. By default, it is \ref MinCostArborescenceDefaultTraits

   /// "MinCostArborescenceDefaultTraits<GR, CM>".

   /// In most cases, this parameter should not be set directly,

   /// consider to use the named template parameters instead.

 #ifndef DOXYGEN

   template <typename GR,

             typename CM = typename GR::template ArcMap<int>,

             typename TR =

               MinCostArborescenceDefaultTraits<GR, CM> >

 #else

   template <typename GR, typename CM, typename TR>

 #endif

   class MinCostArborescence {

   public:

     /// \brief The \ref lemon::MinCostArborescenceDefaultTraits "traits class"

     /// of the algorithm.

     typedef TR Traits;

     /// The type of the underlying digraph.

     typedef typename Traits::Digraph Digraph;

     /// The type of the map that stores the arc costs.

     typedef typename Traits::CostMap CostMap;

     ///The type of the costs of the arcs.

     typedef typename Traits::Value Value;

     ///The type of the predecessor map.

     typedef typename Traits::PredMap PredMap;

     ///The type of the map that stores which arcs are in the arborescence.

     typedef typename Traits::ArborescenceMap ArborescenceMap;

     typedef MinCostArborescence Create;

   private:

     TEMPLATE_DIGRAPH_TYPEDEFS(Digraph);

     struct CostArc {

       Arc arc;

       Value value;

       CostArc() {}

       CostArc(Arc _arc, Value _value) : arc(_arc), value(_value) {}

     };

     const Digraph *_digraph;

     const CostMap *_cost;

     PredMap *_pred;

     bool local_pred;

     ArborescenceMap *_arborescence;

     bool local_arborescence;

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

     ArcOrder *_arc_order;

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

     NodeOrder *_node_order;

     typedef typename Digraph::template NodeMap<CostArc> CostArcMap;

     CostArcMap *_cost_arcs;

     struct StackLevel {

       std::vector<CostArc> arcs;

       int node_level;

     };

     std::vector<StackLevel> level_stack;

     std::vector<Node> queue;

     typedef std::vector<typename Digraph::Node> DualNodeList;

     DualNodeList _dual_node_list;

     struct DualVariable {

       int begin, end;

       Value value;

       DualVariable(int _begin, int _end, Value _value)

         : begin(_begin), end(_end), value(_value) {}

     };

     typedef std::vector<DualVariable> DualVariables;

     DualVariables _dual_variables;

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

     HeapCrossRef *_heap_cross_ref;

     typedef BinHeap<int, HeapCrossRef> Heap;

     Heap *_heap;

   protected:

     MinCostArborescence() {}

   private:

     void createStructures() {

       if (!_pred) {

         local_pred = true;

         _pred = Traits::createPredMap(*_digraph);

       }

       if (!_arborescence) {

         local_arborescence = true;

         _arborescence = Traits::createArborescenceMap(*_digraph);

       }

       if (!_arc_order) {

         _arc_order = new ArcOrder(*_digraph);

       }

       if (!_node_order) {

         _node_order = new NodeOrder(*_digraph);

       }

       if (!_cost_arcs) {

         _cost_arcs = new CostArcMap(*_digraph);

       }

       if (!_heap_cross_ref) {

         _heap_cross_ref = new HeapCrossRef(*_digraph, -1);

       }

       if (!_heap) {

         _heap = new Heap(*_heap_cross_ref);

       }

     }

     void destroyStructures() {

       if (local_arborescence) {

         delete _arborescence;

       }

       if (local_pred) {

         delete _pred;

       }

       if (_arc_order) {

         delete _arc_order;

       }

       if (_node_order) {

         delete _node_order;

       }

       if (_cost_arcs) {

         delete _cost_arcs;

       }

       if (_heap) {

         delete _heap;

       }

       if (_heap_cross_ref) {

         delete _heap_cross_ref;

       }

     }

     Arc prepare(Node node) {

       std::vector<Node> nodes;

       (*_node_order)[node] = _dual_node_list.size();

       StackLevel level;

       level.node_level = _dual_node_list.size();

       _dual_node_list.push_back(node);

       for (InArcIt it(*_digraph, node); it != INVALID; ++it) {

         Arc arc = it;

         Node source = _digraph->source(arc);

         Value value = (*_cost)[it];

         if (source == node || (*_node_order)[source] == -3) continue;

         if ((*_cost_arcs)[source].arc == INVALID) {

           (*_cost_arcs)[source].arc = arc;

           (*_cost_arcs)[source].value = value;

           nodes.push_back(source);

         } else {

           if ((*_cost_arcs)[source].value > value) {

             (*_cost_arcs)[source].arc = arc;

             (*_cost_arcs)[source].value = value;

           }

         }

       }

       CostArc minimum = (*_cost_arcs)[nodes[0]];

       for (int i = 1; i < int(nodes.size()); ++i) {

         if ((*_cost_arcs)[nodes[i]].value < minimum.value) {

           minimum = (*_cost_arcs)[nodes[i]];

         }

       }

       (*_arc_order)[minimum.arc] = _dual_variables.size();

       DualVariable var(_dual_node_list.size() - 1,

                        _dual_node_list.size(), minimum.value);

       _dual_variables.push_back(var);

       for (int i = 0; i < int(nodes.size()); ++i) {

         (*_cost_arcs)[nodes[i]].value -= minimum.value;

         level.arcs.push_back((*_cost_arcs)[nodes[i]]);

         (*_cost_arcs)[nodes[i]].arc = INVALID;

       }

       level_stack.push_back(level);

       return minimum.arc;

     }

     Arc contract(Node node) {

       int node_bottom = bottom(node);

       std::vector<Node> nodes;

       while (!level_stack.empty() &&

              level_stack.back().node_level >= node_bottom) {

         for (int i = 0; i < int(level_stack.back().arcs.size()); ++i) {

           Arc arc = level_stack.back().arcs[i].arc;

           Node source = _digraph->source(arc);

           Value value = level_stack.back().arcs[i].value;

           if ((*_node_order)[source] >= node_bottom) continue;

           if ((*_cost_arcs)[source].arc == INVALID) {

             (*_cost_arcs)[source].arc = arc;

             (*_cost_arcs)[source].value = value;

             nodes.push_back(source);

           } else {

             if ((*_cost_arcs)[source].value > value) {

               (*_cost_arcs)[source].arc = arc;

               (*_cost_arcs)[source].value = value;

             }

           }

         }

         level_stack.pop_back();

       }

       CostArc minimum = (*_cost_arcs)[nodes[0]];

       for (int i = 1; i < int(nodes.size()); ++i) {

         if ((*_cost_arcs)[nodes[i]].value < minimum.value) {

           minimum = (*_cost_arcs)[nodes[i]];

         }

       }

       (*_arc_order)[minimum.arc] = _dual_variables.size();

       DualVariable var(node_bottom, _dual_node_list.size(), minimum.value);

       _dual_variables.push_back(var);

       StackLevel level;

       level.node_level = node_bottom;

       for (int i = 0; i < int(nodes.size()); ++i) {

         (*_cost_arcs)[nodes[i]].value -= minimum.value;

         level.arcs.push_back((*_cost_arcs)[nodes[i]]);

         (*_cost_arcs)[nodes[i]].arc = INVALID;

       }

       level_stack.push_back(level);

       return minimum.arc;

     }

     int bottom(Node node) {

       int k = level_stack.size() - 1;

       while (level_stack[k].node_level > (*_node_order)[node]) {

         --k;

       }

       return level_stack[k].node_level;

     }

     void finalize(Arc arc) {

       Node node = _digraph->target(arc);

       _heap->push(node, (*_arc_order)[arc]);

       _pred->set(node, arc);

       while (!_heap->empty()) {

         Node source = _heap->top();

         _heap->pop();

         (*_node_order)[source] = -1;

         for (OutArcIt it(*_digraph, source); it != INVALID; ++it) {

           if ((*_arc_order)[it] < 0) continue;

           Node target = _digraph->target(it);

           switch(_heap->state(target)) {

           case Heap::PRE_HEAP:

             _heap->push(target, (*_arc_order)[it]);

             _pred->set(target, it);

             break;

           case Heap::IN_HEAP:

             if ((*_arc_order)[it] < (*_heap)[target]) {

               _heap->decrease(target, (*_arc_order)[it]);

               _pred->set(target, it);

             }

             break;

           case Heap::POST_HEAP:

             break;

           }

         }

         _arborescence->set((*_pred)[source], true);

       }

     }

   public:

     /// \name Named Template Parameters

     /// @{

     template <class T>

     struct SetArborescenceMapTraits : public Traits {

       typedef T ArborescenceMap;

       static ArborescenceMap *createArborescenceMap(const Digraph &)

       {

         LEMON_ASSERT(false, "ArborescenceMap is not initialized");

         return 0; // ignore warnings

       }

     };

     /// \brief \ref named-templ-param "Named parameter" for

     /// setting \c ArborescenceMap type

     ///

     /// \ref named-templ-param "Named parameter" for setting

     /// \c ArborescenceMap type.

     /// It must conform to the \ref concepts::WriteMap "WriteMap" concept,

     /// and its value type must be \c bool (or convertible).

     /// Initially it will be set to \c false on each arc,

     /// then it will be set on each arborescence arc once.

     template <class T>

     struct SetArborescenceMap

       : public MinCostArborescence<Digraph, CostMap,

                                    SetArborescenceMapTraits<T> > {

     };

     template <class T>

     struct SetPredMapTraits : public Traits {

       typedef T PredMap;

       static PredMap *createPredMap(const Digraph &)

       {

         LEMON_ASSERT(false, "PredMap is not initialized");

         return 0; // ignore warnings

       }

     };

     /// \brief \ref named-templ-param "Named parameter" for

     /// setting \c PredMap type

     ///

     /// \ref named-templ-param "Named parameter" for setting

     /// \c PredMap type.

     /// It must meet the \ref concepts::WriteMap "WriteMap" concept,

     /// and its value type must be the \c Arc type of the digraph.

     template <class T>

     struct SetPredMap

       : public MinCostArborescence<Digraph, CostMap, SetPredMapTraits<T> > {

     };

     /// @}

     /// \brief Constructor.

     ///

     /// \param digraph The digraph the algorithm will run on.

     /// \param cost The cost map used by the algorithm.

     MinCostArborescence(const Digraph& digraph, const CostMap& cost)

       : _digraph(&digraph), _cost(&cost), _pred(0), local_pred(false),

         _arborescence(0), local_arborescence(false),

         _arc_order(0), _node_order(0), _cost_arcs(0),

         _heap_cross_ref(0), _heap(0) {}

     /// \brief Destructor.

     ~MinCostArborescence() {

       destroyStructures();

     }

     /// \brief Sets the arborescence map.

     ///

     /// Sets the arborescence map.

     /// \return <tt>(*this)</tt>

     MinCostArborescence& arborescenceMap(ArborescenceMap& m) {

       if (local_arborescence) {

         delete _arborescence;

       }

       local_arborescence = false;

       _arborescence = &m;

       return *this;

     }

     /// \brief Sets the predecessor map.

     ///

     /// Sets the predecessor map.

     /// \return <tt>(*this)</tt>

     MinCostArborescence& predMap(PredMap& m) {

       if (local_pred) {

         delete _pred;

       }

       local_pred = false;

       _pred = &m;

       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 better control on the execution,

     /// you have to call \ref init() first, then you can add several

     /// source nodes with \ref addSource().

     /// Finally \ref start() will perform the arborescence

     /// computation.

     ///@{

     /// \brief Initializes the internal data structures.

     ///

     /// Initializes the internal data structures.

     ///

     void init() {

       createStructures();

       _heap->clear();

       for (NodeIt it(*_digraph); it != INVALID; ++it) {

         (*_cost_arcs)[it].arc = INVALID;

         (*_node_order)[it] = -3;

         (*_heap_cross_ref)[it] = Heap::PRE_HEAP;

         _pred->set(it, INVALID);

       }

       for (ArcIt it(*_digraph); it != INVALID; ++it) {

         _arborescence->set(it, false);

         (*_arc_order)[it] = -1;

       }

       _dual_node_list.clear();

       _dual_variables.clear();

     }

     /// \brief Adds a new source node.

     ///

     /// Adds a new source node to the algorithm.

     void addSource(Node source) {

       std::vector<Node> nodes;

       nodes.push_back(source);

       while (!nodes.empty()) {

         Node node = nodes.back();

         nodes.pop_back();

         for (OutArcIt it(*_digraph, node); it != INVALID; ++it) {

           Node target = _digraph->target(it);

           if ((*_node_order)[target] == -3) {

             (*_node_order)[target] = -2;

             nodes.push_back(target);

             queue.push_back(target);

           }

         }

       }

       (*_node_order)[source] = -1;

     }

     /// \brief Processes the next node in the priority queue.

     ///

     /// Processes the next node in the priority queue.

     ///

     /// \return The processed node.

     ///

     /// \warning The queue must not be empty.

     Node processNextNode() {

       Node node = queue.back();

       queue.pop_back();

       if ((*_node_order)[node] == -2) {

         Arc arc = prepare(node);

         Node source = _digraph->source(arc);

         while ((*_node_order)[source] != -1) {

           if ((*_node_order)[source] >= 0) {

             arc = contract(source);

           } else {

             arc = prepare(source);

           }

           source = _digraph->source(arc);

         }

         finalize(arc);

         level_stack.clear();

       }

       return node;

     }

     /// \brief Returns the number of the nodes to be processed.

     ///

     /// Returns the number of the nodes to be processed in the priority

     /// queue.

     int queueSize() const {

       return queue.size();

     }

     /// \brief Returns \c false if there are nodes to be processed.

     ///

     /// Returns \c false if there are nodes to be processed.

     bool emptyQueue() const {

       return queue.empty();

     }

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

     ///

     ///\note mca.start() is just a shortcut of the following code.

     ///\code

     ///while (!mca.emptyQueue()) {

     ///  mca.processNextNode();

     ///}

     ///\endcode

     void start() {

       while (!emptyQueue()) {

         processNextNode();

       }

     }

     /// \brief Runs %MinCostArborescence algorithm from node \c s.

     ///

     /// This method runs the %MinCostArborescence algorithm from

     /// a root node \c s.

     ///

     /// \note mca.run(s) is just a shortcut of the following code.

     /// \code

     /// mca.init();

     /// mca.addSource(s);

     /// mca.start();

     /// \endcode

     void run(Node s) {

       init();

       addSource(s);

       start();

     }

     ///@}

     /// \name Query Functions

     /// The result of the %MinCostArborescence algorithm can be obtained

     /// using these functions.\n

     /// Either run() or start() must be called before using them.

     /// @{

     /// \brief Returns the cost of the arborescence.

     ///

     /// Returns the cost of the arborescence.

     Value arborescenceCost() const {

       Value sum = 0;

       for (ArcIt it(*_digraph); it != INVALID; ++it) {

         if (arborescence(it)) {

           sum += (*_cost)[it];

         }

       }

       return sum;

     }

     /// \brief Returns \c true if the arc is in the arborescence.

     ///

     /// Returns \c true if the given arc is in the arborescence.

     /// \param arc An arc of the digraph.

     /// \pre \ref run() must be called before using this function.

     bool arborescence(Arc arc) const {

       return (*_pred)[_digraph->target(arc)] == arc;

     }

     /// \brief Returns a const reference to the arborescence map.

     ///

     /// Returns a const reference to the arborescence map.

     /// \pre \ref run() must be called before using this function.

     const ArborescenceMap& arborescenceMap() const {

       return *_arborescence;

     }

     /// \brief Returns the predecessor arc of the given node.

     ///

     /// Returns the predecessor arc of the given node.

     /// \pre \ref run() must be called before using this function.

     Arc pred(Node node) const {

       return (*_pred)[node];

     }

     /// \brief Returns a const reference to the pred map.

     ///

     /// Returns a const reference to the pred map.

     /// \pre \ref run() must be called before using this function.

     const PredMap& predMap() const {

       return *_pred;

     }

     /// \brief Indicates that a node is reachable from the sources.

     ///

     /// Indicates that a node is reachable from the sources.

     bool reached(Node node) const {

       return (*_node_order)[node] != -3;

     }

     /// \brief Indicates that a node is processed.

     ///

     /// Indicates that a node is processed. The arborescence path exists

     /// from the source to the given node.

     bool processed(Node node) const {

       return (*_node_order)[node] == -1;

     }

     /// \brief Returns the number of the dual variables in basis.

     ///

     /// Returns the number of the dual variables in basis.

     int dualNum() const {

       return _dual_variables.size();

     }

     /// \brief Returns the value of the dual solution.

     ///

     /// Returns the value of the dual solution. It should be

     /// equal to the arborescence value.

     Value dualValue() const {

       Value sum = 0;

       for (int i = 0; i < int(_dual_variables.size()); ++i) {

         sum += _dual_variables[i].value;

       }

       return sum;

     }

     /// \brief Returns the number of the nodes in the dual variable.

     ///

     /// Returns the number of the nodes in the dual variable.

     int dualSize(int k) const {

       return _dual_variables[k].end - _dual_variables[k].begin;

     }

     /// \brief Returns the value of the dual variable.

     ///

     /// Returns the the value of the dual variable.

     Value dualValue(int k) const {

       return _dual_variables[k].value;

     }

     /// \brief LEMON iterator for getting a dual variable.

     ///

     /// This class provides a common style LEMON iterator for getting a

     /// dual variable of \ref MinCostArborescence algorithm.

     /// It iterates over a subset of the nodes.

     class DualIt {

     public:

       /// \brief Constructor.

       ///

       /// Constructor for getting the nodeset of the dual variable

       /// of \ref MinCostArborescence algorithm.

       DualIt(const MinCostArborescence& algorithm, int variable)

         : _algorithm(&algorithm)

       {

         _index = _algorithm->_dual_variables[variable].begin;

         _last = _algorithm->_dual_variables[variable].end;

       }

       /// \brief Conversion to \c Node.

       ///

       /// Conversion to \c Node.

       operator Node() const {

         return _algorithm->_dual_node_list[_index];

       }

       /// \brief Increment operator.

       ///

       /// Increment operator.

       DualIt& operator++() {

         ++_index;

         return *this;

       }

       /// \brief Validity checking

       ///

       /// Checks whether the iterator is invalid.

       bool operator==(Invalid) const {

         return _index == _last;

       }

       /// \brief Validity checking

       ///

       /// Checks whether the iterator is valid.

       bool operator!=(Invalid) const {

         return _index != _last;

       }

     private:

       const MinCostArborescence* _algorithm;

       int _index, _last;

     };

     /// @}

   };

   /// \ingroup spantree

   ///

   /// \brief Function type interface for MinCostArborescence algorithm.

   ///

   /// Function type interface for MinCostArborescence algorithm.

   /// \param digraph The digraph the algorithm runs on.

   /// \param cost An arc map storing the costs.

   /// \param source The source node of the arborescence.

   /// \retval arborescence An arc map with \c bool (or convertible) value

   /// type that stores the arborescence.

   /// \return The total cost of the arborescence.

   ///

   /// \sa MinCostArborescence

   template <typename Digraph, typename CostMap, typename ArborescenceMap>

   typename CostMap::Value minCostArborescence(const Digraph& digraph,

                                               const CostMap& cost,

                                               typename Digraph::Node source,

                                               ArborescenceMap& arborescence) {

     typename MinCostArborescence<Digraph, CostMap>

       ::template SetArborescenceMap<ArborescenceMap>

       ::Create mca(digraph, cost);

     mca.arborescenceMap(arborescence);

     mca.run(source);

     return mca.arborescenceCost();

   }

 }

 #endif