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

 #define LEMON_CYCLE_CANCELING_H

 /// \ingroup min_cost_flow

 ///

 /// \file

 /// \brief Cycle-canceling algorithm for finding a minimum cost flow.

 #include <vector>

 #include <lemon/graph_adaptor.h>

 #include <lemon/path.h>

 #include <lemon/circulation.h>

 #include <lemon/bellman_ford.h>

 #include <lemon/min_mean_cycle.h>

 namespace lemon {

   /// \addtogroup min_cost_flow

   /// @{

   /// \brief Implementation of a cycle-canceling algorithm for

   /// finding a minimum cost flow.

   ///

   /// \ref CycleCanceling implements a cycle-canceling algorithm for

   /// finding a minimum cost flow.

   ///

   /// \tparam Graph The directed graph type the algorithm runs on.

   /// \tparam LowerMap The type of the lower bound map.

   /// \tparam CapacityMap The type of the capacity (upper bound) map.

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

   /// \tparam SupplyMap The type of the supply map.

   ///

   /// \warning

   /// - Edge capacities and costs should be \e non-negative \e integers.

   /// - Supply values should be \e signed \e integers.

   /// - The value types of the maps should be convertible to each other.

   /// - \c CostMap::Value must be signed type.

   ///

   /// \note By default the \ref BellmanFord "Bellman-Ford" algorithm is

   /// used for negative cycle detection with limited iteration number.

   /// However \ref CycleCanceling also provides the "Minimum Mean

   /// Cycle-Canceling" algorithm, which is \e strongly \e polynomial,

   /// but rather slower in practice.

   /// To use this version of the algorithm, call \ref run() with \c true

   /// parameter.

   ///

   /// \author Peter Kovacs

   template < typename Graph,

              typename LowerMap = typename Graph::template EdgeMap<int>,

              typename CapacityMap = typename Graph::template EdgeMap<int>,

              typename CostMap = typename Graph::template EdgeMap<int>,

              typename SupplyMap = typename Graph::template NodeMap<int> >

   class CycleCanceling

   {

     GRAPH_TYPEDEFS(typename Graph);

     typedef typename CapacityMap::Value Capacity;

     typedef typename CostMap::Value Cost;

     typedef typename SupplyMap::Value Supply;

     typedef typename Graph::template EdgeMap<Capacity> CapacityEdgeMap;

     typedef typename Graph::template NodeMap<Supply> SupplyNodeMap;

     typedef ResGraphAdaptor< const Graph, Capacity,

                              CapacityEdgeMap, CapacityEdgeMap > ResGraph;

     typedef typename ResGraph::Node ResNode;

     typedef typename ResGraph::NodeIt ResNodeIt;

     typedef typename ResGraph::Edge ResEdge;

     typedef typename ResGraph::EdgeIt ResEdgeIt;

   public:

     /// The type of the flow map.

     typedef typename Graph::template EdgeMap<Capacity> FlowMap;

     /// The type of the potential map.

     typedef typename Graph::template NodeMap<Cost> PotentialMap;

   private:

     /// \brief Map adaptor class for handling residual edge costs.

     ///

     /// Map adaptor class for handling residual edge costs.

     class ResidualCostMap : public MapBase<ResEdge, Cost>

     {

     private:

       const CostMap &_cost_map;

     public:

       ///\e

       ResidualCostMap(const CostMap &cost_map) : _cost_map(cost_map) {}

       ///\e

       Cost operator[](const ResEdge &e) const {

         return ResGraph::forward(e) ? _cost_map[e] : -_cost_map[e];

       }

     }; //class ResidualCostMap

   private:

     // The maximum number of iterations for the first execution of the

     // Bellman-Ford algorithm. It should be at least 2.

     static const int BF_FIRST_LIMIT  = 2;

     // The iteration limit for the Bellman-Ford algorithm is multiplied

     // by BF_LIMIT_FACTOR/100 in every round.

     static const int BF_LIMIT_FACTOR = 150;

   private:

     // The directed graph the algorithm runs on

     const Graph &_graph;

     // The original lower bound map

     const LowerMap *_lower;

     // The modified capacity map

     CapacityEdgeMap _capacity;

     // The original cost map

     const CostMap &_cost;

     // The modified supply map

     SupplyNodeMap _supply;

     bool _valid_supply;

     // Edge map of the current flow

     FlowMap *_flow;

     bool _local_flow;

     // Node map of the current potentials

     PotentialMap *_potential;

     bool _local_potential;

     // The residual graph

     ResGraph *_res_graph;

     // The residual cost map

     ResidualCostMap _res_cost;

   public:

     /// \brief General constructor (with lower bounds).

     ///

     /// General constructor (with lower bounds).

     ///

     /// \param graph The directed graph the algorithm runs on.

     /// \param lower The lower bounds of the edges.

     /// \param capacity The capacities (upper bounds) of the edges.

     /// \param cost The cost (length) values of the edges.

     /// \param supply The supply values of the nodes (signed).

     CycleCanceling( const Graph &graph,

                     const LowerMap &lower,

                     const CapacityMap &capacity,

                     const CostMap &cost,

                     const SupplyMap &supply ) :

       _graph(graph), _lower(&lower), _capacity(graph), _cost(cost),

       _supply(graph), _flow(0), _local_flow(false),

       _potential(0), _local_potential(false), _res_cost(_cost)

     {

       // Removing non-zero lower bounds

       _capacity = subMap(capacity, lower);

       Supply sum = 0;

       for (NodeIt n(_graph); n != INVALID; ++n) {

         Supply s = supply[n];

         for (InEdgeIt e(_graph, n); e != INVALID; ++e)

           s += lower[e];

         for (OutEdgeIt e(_graph, n); e != INVALID; ++e)

           s -= lower[e];

         sum += (_supply[n] = s);

       }

       _valid_supply = sum == 0;

     }

     /// \brief General constructor (without lower bounds).

     ///

     /// General constructor (without lower bounds).

     ///

     /// \param graph The directed graph the algorithm runs on.

     /// \param capacity The capacities (upper bounds) of the edges.

     /// \param cost The cost (length) values of the edges.

     /// \param supply The supply values of the nodes (signed).

     CycleCanceling( const Graph &graph,

                     const CapacityMap &capacity,

                     const CostMap &cost,

                     const SupplyMap &supply ) :

       _graph(graph), _lower(NULL), _capacity(capacity), _cost(cost),

       _supply(supply), _flow(0), _local_flow(false),

       _potential(0), _local_potential(false), _res_cost(_cost)

     {

       // Checking the sum of supply values

       Supply sum = 0;

       for (NodeIt n(_graph); n != INVALID; ++n) sum += _supply[n];

       _valid_supply = sum == 0;

     }

     /// \brief Simple constructor (with lower bounds).

     ///

     /// Simple constructor (with lower bounds).

     ///

     /// \param graph The directed graph the algorithm runs on.

     /// \param lower The lower bounds of the edges.

     /// \param capacity The capacities (upper bounds) of the edges.

     /// \param cost The cost (length) values of the edges.

     /// \param s The source node.

     /// \param t The target node.

     /// \param flow_value The required amount of flow from node \c s

     /// to node \c t (i.e. the supply of \c s and the demand of \c t).

     CycleCanceling( const Graph &graph,

                     const LowerMap &lower,

                     const CapacityMap &capacity,

                     const CostMap &cost,

                     Node s, Node t,

                     Supply flow_value ) :

       _graph(graph), _lower(&lower), _capacity(graph), _cost(cost),

       _supply(graph), _flow(0), _local_flow(false),

       _potential(0), _local_potential(false), _res_cost(_cost)

     {

       // Removing non-zero lower bounds

       _capacity = subMap(capacity, lower);

       for (NodeIt n(_graph); n != INVALID; ++n) {

         Supply sum = 0;

         if (n == s) sum =  flow_value;

         if (n == t) sum = -flow_value;

         for (InEdgeIt e(_graph, n); e != INVALID; ++e)

           sum += lower[e];

         for (OutEdgeIt e(_graph, n); e != INVALID; ++e)

           sum -= lower[e];

         _supply[n] = sum;

       }

       _valid_supply = true;

     }

     /// \brief Simple constructor (without lower bounds).

     ///

     /// Simple constructor (without lower bounds).

     ///

     /// \param graph The directed graph the algorithm runs on.

     /// \param capacity The capacities (upper bounds) of the edges.

     /// \param cost The cost (length) values of the edges.

     /// \param s The source node.

     /// \param t The target node.

     /// \param flow_value The required amount of flow from node \c s

     /// to node \c t (i.e. the supply of \c s and the demand of \c t).

     CycleCanceling( const Graph &graph,

                     const CapacityMap &capacity,

                     const CostMap &cost,

                     Node s, Node t,

                     Supply flow_value ) :

       _graph(graph), _lower(NULL), _capacity(capacity), _cost(cost),

       _supply(graph, 0), _flow(0), _local_flow(false),

       _potential(0), _local_potential(false), _res_cost(_cost)

     {

       _supply[s] =  flow_value;

       _supply[t] = -flow_value;

       _valid_supply = true;

     }

     /// Destructor.

     ~CycleCanceling() {

       if (_local_flow) delete _flow;

       if (_local_potential) delete _potential;

       delete _res_graph;

     }

     /// \brief Set the flow map.

     ///

     /// Set the flow map.

     ///

     /// \return \c (*this)

     CycleCanceling& flowMap(FlowMap &map) {

       if (_local_flow) {

         delete _flow;

         _local_flow = false;

       }

       _flow = ↦

       return *this;

     }

     /// \brief Set the potential map.

     ///

     /// Set the potential map.

     ///

     /// \return \c (*this)

     CycleCanceling& potentialMap(PotentialMap &map) {

       if (_local_potential) {

         delete _potential;

         _local_potential = false;

       }

       _potential = ↦

       return *this;

     }

     /// \name Execution control

     /// @{

     /// \brief Run the algorithm.

     ///

     /// Run the algorithm.

     ///

     /// \param min_mean_cc Set this parameter to \c true to run the

     /// "Minimum Mean Cycle-Canceling" algorithm, which is strongly

     /// polynomial, but rather slower in practice.

     ///

     /// \return \c true if a feasible flow can be found.

     bool run(bool min_mean_cc = false) {

       return init() && start(min_mean_cc);

     }

     /// @}

     /// \name Query Functions

     /// The result of the algorithm can be obtained using these

     /// functions.\n

     /// \ref lemon::CycleCanceling::run() "run()" must be called before

     /// using them.

     /// @{

     /// \brief Return a const reference to the edge map storing the

     /// found flow.

     ///

     /// Return a const reference to the edge map storing the found flow.

     ///

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

     const FlowMap& flowMap() const {

       return *_flow;

     }

     /// \brief Return a const reference to the node map storing the

     /// found potentials (the dual solution).

     ///

     /// Return a const reference to the node map storing the found

     /// potentials (the dual solution).

     ///

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

     const PotentialMap& potentialMap() const {

       return *_potential;

     }

     /// \brief Return the flow on the given edge.

     ///

     /// Return the flow on the given edge.

     ///

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

     Capacity flow(const Edge& edge) const {

       return (*_flow)[edge];

     }

     /// \brief Return the potential of the given node.

     ///

     /// Return the potential of the given node.

     ///

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

     Cost potential(const Node& node) const {

       return (*_potential)[node];

     }

     /// \brief Return the total cost of the found flow.

     ///

     /// Return the total cost of the found flow. The complexity of the

     /// function is \f$ O(e) \f$.

     ///

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

     Cost totalCost() const {

       Cost c = 0;

       for (EdgeIt e(_graph); e != INVALID; ++e)

         c += (*_flow)[e] * _cost[e];

       return c;

     }

     /// @}

   private:

     /// Initialize the algorithm.

     bool init() {

       if (!_valid_supply) return false;

       // Initializing flow and potential maps

       if (!_flow) {

         _flow = new FlowMap(_graph);

         _local_flow = true;

       }

       if (!_potential) {

         _potential = new PotentialMap(_graph);

         _local_potential = true;

       }

       _res_graph = new ResGraph(_graph, _capacity, *_flow);

       // Finding a feasible flow using Circulation

       Circulation< Graph, ConstMap<Edge, Capacity>, CapacityEdgeMap,

                    SupplyMap >

         circulation( _graph, constMap<Edge>(Capacity(0)), _capacity,

                      _supply );

       return circulation.flowMap(*_flow).run();

     }

     bool start(bool min_mean_cc) {

       if (min_mean_cc)

         startMinMean();

       else

         start();

       // Handling non-zero lower bounds

       if (_lower) {

         for (EdgeIt e(_graph); e != INVALID; ++e)

           (*_flow)[e] += (*_lower)[e];

       }

       return true;

     }

     /// \brief Execute the algorithm using \ref BellmanFord.

     ///

     /// Execute the algorithm using the \ref BellmanFord

     /// "Bellman-Ford" algorithm for negative cycle detection with

     /// successively larger limit for the number of iterations.

     void start() {

       typename BellmanFord<ResGraph, ResidualCostMap>::PredMap pred(*_res_graph);

       typename ResGraph::template NodeMap<int> visited(*_res_graph);

       std::vector<ResEdge> cycle;

       int node_num = countNodes(_graph);

       int length_bound = BF_FIRST_LIMIT;

       bool optimal = false;

       while (!optimal) {

         BellmanFord<ResGraph, ResidualCostMap> bf(*_res_graph, _res_cost);

         bf.predMap(pred);

         bf.init(0);

         int iter_num = 0;

         bool cycle_found = false;

         while (!cycle_found) {

           int curr_iter_num = iter_num + length_bound <= node_num ?

                               length_bound : node_num - iter_num;

           iter_num += curr_iter_num;

           int real_iter_num = curr_iter_num;

           for (int i = 0; i < curr_iter_num; ++i) {

             if (bf.processNextWeakRound()) {

               real_iter_num = i;

               break;

             }

           }

           if (real_iter_num < curr_iter_num) {

             // Optimal flow is found

             optimal = true;

             // Setting node potentials

             for (NodeIt n(_graph); n != INVALID; ++n)

               (*_potential)[n] = bf.dist(n);

             break;

           } else {

             // Searching for node disjoint negative cycles

             for (ResNodeIt n(*_res_graph); n != INVALID; ++n)

               visited[n] = 0;

             int id = 0;

             for (ResNodeIt n(*_res_graph); n != INVALID; ++n) {

               if (visited[n] > 0) continue;

               visited[n] = ++id;

               ResNode u = pred[n] == INVALID ?

                           INVALID : _res_graph->source(pred[n]);

               while (u != INVALID && visited[u] == 0) {

                 visited[u] = id;

                 u = pred[u] == INVALID ?

                     INVALID : _res_graph->source(pred[u]);

               }

               if (u != INVALID && visited[u] == id) {

                 // Finding the negative cycle

                 cycle_found = true;

                 cycle.clear();

                 ResEdge e = pred[u];

                 cycle.push_back(e);

                 Capacity d = _res_graph->rescap(e);

                 while (_res_graph->source(e) != u) {

                   cycle.push_back(e = pred[_res_graph->source(e)]);

                   if (_res_graph->rescap(e) < d)

                     d = _res_graph->rescap(e);

                 }

                 // Augmenting along the cycle

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

                   _res_graph->augment(cycle[i], d);

               }

             }

           }

           if (!cycle_found)

             length_bound = length_bound * BF_LIMIT_FACTOR / 100;

         }

       }

     }

     /// \brief Execute the algorithm using \ref MinMeanCycle.

     ///

     /// Execute the algorithm using \ref MinMeanCycle for negative

     /// cycle detection.

     void startMinMean() {

       typedef Path<ResGraph> ResPath;

       MinMeanCycle<ResGraph, ResidualCostMap> mmc(*_res_graph, _res_cost);

       ResPath cycle;

       mmc.cyclePath(cycle).init();

       if (mmc.findMinMean()) {

         while (mmc.cycleLength() < 0) {

           // Finding the cycle

           mmc.findCycle();

           // Finding the largest flow amount that can be augmented

           // along the cycle

           Capacity delta = 0;

           for (typename ResPath::EdgeIt e(cycle); e != INVALID; ++e) {

             if (delta == 0 || _res_graph->rescap(e) < delta)

               delta = _res_graph->rescap(e);

           }

           // Augmenting along the cycle

           for (typename ResPath::EdgeIt e(cycle); e != INVALID; ++e)

             _res_graph->augment(e, delta);

           // Finding the minimum cycle mean for the modified residual

           // graph

           mmc.reset();

           if (!mmc.findMinMean()) break;

         }

       }

       // Computing node potentials

       BellmanFord<ResGraph, ResidualCostMap> bf(*_res_graph, _res_cost);

       bf.init(0); bf.start();

       for (NodeIt n(_graph); n != INVALID; ++n)

         (*_potential)[n] = bf.dist(n);

     }

   }; //class CycleCanceling

   ///@}

 } //namespace lemon

 #endif //LEMON_CYCLE_CANCELING_H