/* -*- C++ -*-

  *

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

  *

  * Copyright (C) 2003-2007

  * 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 A cycle-canceling algorithm for finding a minimum cost flow.

 #include <vector>

 #include <lemon/graph_adaptor.h>

 #include <lemon/circulation.h>

 /// \brief The used cycle-canceling method.

 #define LIMITED_CYCLE_CANCELING

 //#define MIN_MEAN_CYCLE_CANCELING

 #ifdef LIMITED_CYCLE_CANCELING

   #include <lemon/bellman_ford.h>

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

   /// of the \ref lemon::BellmanFord "Bellman-Ford" algorithm.

   /// It should be at least 2.

   #define STARTING_LIMIT	2

   /// \brief The iteration limit for the

   /// \ref lemon::BellmanFord "Bellman-Ford" algorithm is multiplied by

   /// <tt>ALPHA_MUL / ALPHA_DIV</tt> in every round.

   /// <tt>ALPHA_MUL / ALPHA_DIV</tt> must be greater than 1.

   #define ALPHA_MUL		3

   /// \brief The iteration limit for the

   /// \ref lemon::BellmanFord "Bellman-Ford" algorithm is multiplied by

   /// <tt>ALPHA_MUL / ALPHA_DIV</tt> in every round.

   /// <tt>ALPHA_MUL / ALPHA_DIV</tt> must be greater than 1.

   #define ALPHA_DIV		2

 //#define _ONLY_ONE_CYCLE_

 //#define _NO_BACK_STEP_

 //#define _DEBUG_ITER_

 #endif

 #ifdef MIN_MEAN_CYCLE_CANCELING

   #include <lemon/min_mean_cycle.h>

   #include <lemon/path.h>

 #endif

 namespace lemon {

   /// \addtogroup min_cost_flow

   /// @{

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

   /// a minimum cost flow.

   ///

   /// \ref lemon::CycleCanceling "CycleCanceling" implements a

   /// cycle-canceling algorithm for finding a minimum cost flow.

   ///

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

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

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

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

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

   ///

   /// \warning

   /// - Edge capacities and costs should be nonnegative integers.

   ///	However \c CostMap::Value should be signed type.

   /// - Supply values should be signed integers.

   /// - \c LowerMap::Value must be convertible to

   ///	\c CapacityMap::Value and \c CapacityMap::Value must be

   ///	convertible to \c SupplyMap::Value.

   ///

   /// \author Peter Kovacs

   template < typename Graph,

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

              typename CapacityMap = LowerMap,

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

              typename SupplyMap = typename Graph::template NodeMap

                                   <typename CapacityMap::Value> >

   class CycleCanceling

   {

     typedef typename Graph::Node Node;

     typedef typename Graph::NodeIt NodeIt;

     typedef typename Graph::Edge Edge;

     typedef typename Graph::EdgeIt EdgeIt;

     typedef typename Graph::InEdgeIt InEdgeIt;

     typedef typename Graph::OutEdgeIt OutEdgeIt;

     typedef typename LowerMap::Value Lower;

     typedef typename CapacityMap::Value Capacity;

     typedef typename CostMap::Value Cost;

     typedef typename SupplyMap::Value Supply;

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

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

     typedef ResGraphAdaptor< const Graph, Capacity,

 			     CapacityRefMap, CapacityRefMap > ResGraph;

     typedef typename ResGraph::Node ResNode;

     typedef typename ResGraph::NodeIt ResNodeIt;

     typedef typename ResGraph::Edge ResEdge;

     typedef typename ResGraph::EdgeIt ResEdgeIt;

   public:

     /// \brief The type of the flow map.

     typedef CapacityRefMap FlowMap;

   protected:

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

     class ResCostMap : public MapBase<ResEdge, Cost>

     {

     private:

       const CostMap &cost_map;

     public:

       ResCostMap(const CostMap &_cost) : cost_map(_cost) {}

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

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

       }

     }; //class ResCostMap

   protected:

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

     const Graph &graph;

     /// \brief The original lower bound map.

     const LowerMap *lower;

     /// \brief The modified capacity map.

     CapacityRefMap capacity;

     /// \brief The cost map.

     const CostMap &cost;

     /// \brief The modified supply map.

     SupplyRefMap supply;

     /// \brief The sum of supply values equals zero.

     bool valid_supply;

     /// \brief The current flow.

     FlowMap flow;

     /// \brief The residual graph.

     ResGraph res_graph;

     /// \brief The residual cost map.

     ResCostMap res_cost;

   public :

     /// \brief General constructor of the class (with lower bounds).

     ///

     /// General constructor of the class (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(_graph, 0),

       res_graph(_graph, capacity, flow), res_cost(cost)

     {

       // Removing nonzero 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 of the class (without lower bounds).

     ///

     /// General constructor of the class (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(_graph, 0),

       res_graph(_graph, capacity, flow), 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 of the class (with lower bounds).

     ///

     /// Simple constructor of the class (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(_graph, 0),

       res_graph(_graph, capacity, flow), res_cost(cost)

     {

       // Removing nonzero lower bounds

       capacity = subMap(_capacity, _lower);

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

 	Supply s = 0;

 	if (n == _s) s =  _flow_value;

 	if (n == _t) s = -_flow_value;

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

 	  s += _lower[e];

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

 	  s -= _lower[e];

 	supply[n] = s;

       }

       valid_supply = true;

     }

     /// \brief Simple constructor of the class (without lower bounds).

     ///

     /// Simple constructor of the class (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(_graph, 0),

       res_graph(_graph, capacity, flow), res_cost(cost)

     {

       supply[_s] =  _flow_value;

       supply[_t] = -_flow_value;

       valid_supply = true;

     }

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

     ///

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

     ///

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

     const FlowMap& flowMap() const {

       return flow;

     }

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

     ///

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

     }

     /// \brief Runs the algorithm.

     ///

     /// Runs the algorithm.

     ///

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

     bool run() {

       return init() && start();

     }

   protected:

     /// \brief Initializes the algorithm.

     bool init() {

       // Checking the sum of supply values

       Supply sum = 0;

       for (NodeIt n(graph); n != INVALID; ++n) sum += supply[n];

       if (sum != 0) return false;

       // Finding a feasible flow

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

 		   SupplyMap >

 	circulation( graph, constMap<Edge>((Capacity)0), capacity, 

 		     supply );

       circulation.flowMap(flow);

       return circulation.run() == -1;

     }

 #ifdef LIMITED_CYCLE_CANCELING

     /// \brief Executes a cycle-canceling algorithm using

     /// \ref lemon::BellmanFord "Bellman-Ford" algorithm with limited

     /// iteration count.

     bool start() {

       typename BellmanFord<ResGraph, ResCostMap>::PredMap pred(res_graph);

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

       std::vector<ResEdge> cycle;

       int node_num = countNodes(graph);

 #ifdef _DEBUG_ITER_

       int cycle_num = 0;

 #endif

       int length_bound = STARTING_LIMIT;

       bool optimal = false;

       while (!optimal) {

 	BellmanFord<ResGraph, ResCostMap> bf(res_graph, res_cost);

 	bf.predMap(pred);

 	bf.init(0);

 	int iter_num = 0;

 	bool cycle_found = false;

 	while (!cycle_found) {

 #ifdef _NO_BACK_STEP_

 	  int curr_iter_num = length_bound <= node_num ?

 			      length_bound - iter_num : node_num - iter_num;

 #else

 	  int curr_iter_num = iter_num + length_bound <= node_num ?

 			      length_bound : node_num - iter_num;

 #endif

 	  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 = true;

 	    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);

 		}

 #ifdef _DEBUG_ITER_

 		++cycle_num;

 #endif

 		// Augmenting along the cycle

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

 		  res_graph.augment(cycle[i], d);

 #ifdef _ONLY_ONE_CYCLE_

 		break;

 #endif

 	      }

 	    }

 	  }

 	  if (!cycle_found)

 	    length_bound = length_bound * ALPHA_MUL / ALPHA_DIV;

 	}

       }

 #ifdef _DEBUG_ITER_

       std::cout << "Limited cycle-canceling algorithm finished. "

 		<< "Found " << cycle_num << " negative cycles."

 		<< std::endl;

 #endif

       // Handling nonzero lower bounds

       if (lower) {

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

 	  flow[e] += (*lower)[e];

       }

       return true;

     }

 #endif

 #ifdef MIN_MEAN_CYCLE_CANCELING

     /// \brief Executes the minimum mean cycle-canceling algorithm

     /// using \ref lemon::MinMeanCycle "MinMeanCycle" class.

     bool start() {

       typedef Path<ResGraph> ResPath;

       MinMeanCycle<ResGraph, ResCostMap> mmc(res_graph, res_cost);

       ResPath cycle;

 #ifdef _DEBUG_ITER_

       int cycle_num = 0;

 #endif

       mmc.cyclePath(cycle).init();

       if (mmc.findMinMean()) {

 	while (mmc.cycleLength() < 0) {

 #ifdef _DEBUG_ITER_

 	  ++iter;

 #endif

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

 	}

       }

 #ifdef _DEBUG_ITER_

       std::cout << "Minimum mean cycle-canceling algorithm finished. "

 		<< "Found " << cycle_num << " negative cycles."

 		<< std::endl;

 #endif

       // Handling nonzero lower bounds

       if (lower) {

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

 	  flow[e] += (*lower)[e];

       }

       return true;

     }

 #endif

   }; //class CycleCanceling

   ///@}

 } //namespace lemon

 #endif //LEMON_CYCLE_CANCELING_H