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

#define LEMON_COST_SCALING_H

/// \ingroup min_cost_flow

///

/// \file

/// \brief Cost scaling algorithm for finding a minimum cost flow.

#include <deque>

#include <lemon/graph_adaptor.h>

#include <lemon/graph_utils.h>

#include <lemon/maps.h>

#include <lemon/math.h>

#include <lemon/circulation.h>

#include <lemon/bellman_ford.h>

namespace lemon {

  /// \addtogroup min_cost_flow

  /// @{

  /// \brief Implementation of the cost scaling algorithm for finding a

  /// minimum cost flow.

  ///

  /// \ref CostScaling implements the cost scaling algorithm performing

  /// generalized push-relabel operations 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.

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

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

  ///   convertible to each other.

  /// - All value types must be convertible to \c CostMap::Value, which

  ///   must be signed type.

  ///

  /// \note Edge costs are multiplied with the number of nodes during

  /// the algorithm so overflow problems may arise more easily than with

  /// other minimum cost flow algorithms.

  /// If it is available, <tt>long long int</tt> type is used instead of

  /// <tt>long int</tt> in the inside computations.

  ///

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

  {

    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::Edge ResEdge;

#if defined __GNUC__ && !defined __STRICT_ANSI__

    typedef long long int LCost;

#else

    typedef long int LCost;

#endif

    typedef typename Graph::template EdgeMap<LCost> LargeCostMap;

  public:

    /// The type of the flow map.

    typedef CapacityEdgeMap FlowMap;

    /// The type of the potential map.

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

  private:

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

    ///

    /// \ref ResidualCostMap is a map adaptor class for handling

    /// residual edge costs.

    class ResidualCostMap : public MapBase<ResEdge, LCost>

    {

    private:

      const LargeCostMap &_cost_map;

    public:

      ///\e

      ResidualCostMap(const LargeCostMap &cost_map) :

        _cost_map(cost_map) {}

      ///\e

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

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

      }

    }; //class ResidualCostMap

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

    ///

    /// \ref ReducedCostMap is a map adaptor class for handling reduced

    /// edge costs.

    class ReducedCostMap : public MapBase<Edge, LCost>

    {

    private:

      const Graph &_gr;

      const LargeCostMap &_cost_map;

      const PotentialMap &_pot_map;

    public:

      ///\e

      ReducedCostMap( const Graph &gr,

                      const LargeCostMap &cost_map,

                      const PotentialMap &pot_map ) :

        _gr(gr), _cost_map(cost_map), _pot_map(pot_map) {}

      ///\e

      LCost operator[](const Edge &e) const {

        return _cost_map[e] + _pot_map[_gr.source(e)]

                            - _pot_map[_gr.target(e)];

      }

    }; //class ReducedCostMap

  private:

    // Scaling factor

    static const int ALPHA = 4;

    // Paramters for heuristics

    static const int BF_HEURISTIC_EPSILON_BOUND    = 5000;

    static const int BF_HEURISTIC_BOUND_FACTOR = 3;

  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 &_orig_cost;

    // The scaled cost map

    LargeCostMap _cost;

    // The modified supply map

    SupplyNodeMap _supply;

    bool _valid_supply;

    // Edge map of the current flow

    FlowMap _flow;

    // Node map of the current potentials

    PotentialMap _potential;

    // The residual graph

    ResGraph _res_graph;

    // The residual cost map

    ResidualCostMap _res_cost;

    // The reduced cost map

    ReducedCostMap _red_cost;

    // The excess map

    SupplyNodeMap _excess;

    // The epsilon parameter used for cost scaling

    LCost _epsilon;

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

    CostScaling( const Graph &graph,

                 const LowerMap &lower,

                 const CapacityMap &capacity,

                 const CostMap &cost,

                 const SupplyMap &supply ) :

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

      _cost(graph), _supply(graph), _flow(graph, 0), _potential(graph, 0),

      _res_graph(graph, _capacity, _flow), _res_cost(_cost),

      _red_cost(graph, _cost, _potential), _excess(graph, 0)

    {

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

        _supply[n] = s;

        sum += 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).

    CostScaling( const Graph &graph,

                 const CapacityMap &capacity,

                 const CostMap &cost,

                 const SupplyMap &supply ) :

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

      _cost(graph), _supply(supply), _flow(graph, 0), _potential(graph, 0),

      _res_graph(graph, _capacity, _flow), _res_cost(_cost),

      _red_cost(graph, _cost, _potential), _excess(graph, 0)

    {

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

    CostScaling( 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), _orig_cost(cost),

      _cost(graph), _supply(graph), _flow(graph, 0), _potential(graph, 0),

      _res_graph(graph, _capacity, _flow), _res_cost(_cost),

      _red_cost(graph, _cost, _potential), _excess(graph, 0)

    {

      // Removing nonzero 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 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).

    CostScaling( const Graph &graph,

                 const CapacityMap &capacity,

                 const CostMap &cost,

                 Node s, Node t,

                 Supply flow_value ) :

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

      _cost(graph), _supply(graph, 0), _flow(graph, 0), _potential(graph, 0),

      _res_graph(graph, _capacity, _flow), _res_cost(_cost),

      _red_cost(graph, _cost, _potential), _excess(graph, 0)

    {

      _supply[s] =  flow_value;

      _supply[t] = -flow_value;

      _valid_supply = true;

    }

    /// \brief Runs the algorithm.

    ///

    /// Runs the algorithm.

    ///

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

    bool run() {

      init() && start();

    }

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

    /// found flow.

    ///

    /// Returns 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 Returns a const reference to the node map storing the

    /// found potentials (the dual solution).

    ///

    /// Returns 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 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] * _orig_cost[e];

      return c;

    }

  private:

    /// Initializes the algorithm.

    bool init() {

      if (!_valid_supply) return false;

      // Initializing the scaled cost map and the epsilon parameter

      Cost max_cost = 0;

      int node_num = countNodes(_graph);

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

        _cost[e] = LCost(_orig_cost[e]) * node_num * ALPHA;

        if (_orig_cost[e] > max_cost) max_cost = _orig_cost[e];

      }

      _epsilon = max_cost * node_num;

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

    }

    /// Executes the algorithm.

    bool start() {

      std::deque<Node> active_nodes;

      typename Graph::template NodeMap<bool> hyper(_graph, false);

      int node_num = countNodes(_graph);

      for ( ; _epsilon >= 1; _epsilon = _epsilon < ALPHA && _epsilon > 1 ?

                                        1 : _epsilon / ALPHA )

      {

        // Performing price refinement heuristic using Bellman-Ford

        // algorithm

        if (_epsilon <= BF_HEURISTIC_EPSILON_BOUND) {

          typedef ShiftMap<ResidualCostMap> ShiftCostMap;

          ShiftCostMap shift_cost(_res_cost, _epsilon);

          BellmanFord<ResGraph, ShiftCostMap> bf(_res_graph, shift_cost);

          bf.init(0);

          bool done = false;

          int K = int(BF_HEURISTIC_BOUND_FACTOR * sqrt(node_num));

          for (int i = 0; i < K && !done; ++i)

            done = bf.processNextWeakRound();

          if (done) {

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

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

            continue;

          }

        }

        // Saturating edges not satisfying the optimality condition

        Capacity delta;

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

          if (_capacity[e] - _flow[e] > 0 && _red_cost[e] < 0) {

            delta = _capacity[e] - _flow[e];

            _excess[_graph.source(e)] -= delta;

            _excess[_graph.target(e)] += delta;

            _flow[e] = _capacity[e];

          }

          if (_flow[e] > 0 && -_red_cost[e] < 0) {

            _excess[_graph.target(e)] -= _flow[e];

            _excess[_graph.source(e)] += _flow[e];

            _flow[e] = 0;

          }

        }

        // Finding active nodes (i.e. nodes with positive excess)

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

          if (_excess[n] > 0) active_nodes.push_back(n);

        // Performing push and relabel operations

        while (active_nodes.size() > 0) {

          Node n = active_nodes[0], t;

          bool relabel_enabled = true;

          // Performing push operations if there are admissible edges

          if (_excess[n] > 0) {

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

              if (_capacity[e] - _flow[e] > 0 && _red_cost[e] < 0) {

                delta = _capacity[e] - _flow[e] <= _excess[n] ?

                        _capacity[e] - _flow[e] : _excess[n];

                t = _graph.target(e);

                // Push-look-ahead heuristic

                Capacity ahead = -_excess[t];

                for (OutEdgeIt oe(_graph, t); oe != INVALID; ++oe) {

                  if (_capacity[oe] - _flow[oe] > 0 && _red_cost[oe] < 0)

                    ahead += _capacity[oe] - _flow[oe];

                }

                for (InEdgeIt ie(_graph, t); ie != INVALID; ++ie) {

                  if (_flow[ie] > 0 && -_red_cost[ie] < 0)

                    ahead += _flow[ie];

                }

                if (ahead < 0) ahead = 0;

                // Pushing flow along the edge

                if (ahead < delta) {

                  _flow[e] += ahead;

                  _excess[n] -= ahead;

                  _excess[t] += ahead;

                  active_nodes.push_front(t);

                  hyper[t] = true;

                  relabel_enabled = false;

                  break;

                } else {

                  _flow[e] += delta;

                  _excess[n] -= delta;

                  _excess[t] += delta;

                  if (_excess[t] > 0 && _excess[t] <= delta)

                    active_nodes.push_back(t);

                }

                if (_excess[n] == 0) break;

              }

            }

          }

          if (_excess[n] > 0) {

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

              if (_flow[e] > 0 && -_red_cost[e] < 0) {

                delta = _flow[e] <= _excess[n] ? _flow[e] : _excess[n];

                t = _graph.source(e);

                // Push-look-ahead heuristic

                Capacity ahead = -_excess[t];

                for (OutEdgeIt oe(_graph, t); oe != INVALID; ++oe) {

                  if (_capacity[oe] - _flow[oe] > 0 && _red_cost[oe] < 0)

                    ahead += _capacity[oe] - _flow[oe];

                }

                for (InEdgeIt ie(_graph, t); ie != INVALID; ++ie) {

                  if (_flow[ie] > 0 && -_red_cost[ie] < 0)

                    ahead += _flow[ie];

                }

                if (ahead < 0) ahead = 0;

                // Pushing flow along the edge

                if (ahead < delta) {

                  _flow[e] -= ahead;

                  _excess[n] -= ahead;

                  _excess[t] += ahead;

                  active_nodes.push_front(t);

                  hyper[t] = true;

                  relabel_enabled = false;

                  break;

                } else {

                  _flow[e] -= delta;

                  _excess[n] -= delta;

                  _excess[t] += delta;

                  if (_excess[t] > 0 && _excess[t] <= delta)

                    active_nodes.push_back(t);

                }

                if (_excess[n] == 0) break;

              }

            }

          }

          if (relabel_enabled && (_excess[n] > 0 || hyper[n])) {

            // Performing relabel operation if the node is still active

            LCost min_red_cost = std::numeric_limits<LCost>::max();

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

              if ( _capacity[oe] - _flow[oe] > 0 &&

                   _red_cost[oe] < min_red_cost )

                min_red_cost = _red_cost[oe];

            }

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

              if (_flow[ie] > 0 && -_red_cost[ie] < min_red_cost)

                min_red_cost = -_red_cost[ie];

            }

            _potential[n] -= min_red_cost + _epsilon;

            hyper[n] = false;

          }

          // Removing active nodes with non-positive excess

          while ( active_nodes.size() > 0 &&

                  _excess[active_nodes[0]] <= 0 &&

                  !hyper[active_nodes[0]] ) {

            active_nodes.pop_front();

          }

        }

      }

      // Handling non-zero lower bounds

      if (_lower) {

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

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

      }

      return true;

    }

  }; //class CostScaling

  ///@}

} //namespace lemon

#endif //LEMON_COST_SCALING_H