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

#define LEMON_MIN_COST_MAX_FLOW_H

/// \ingroup min_cost_flow

///

/// \file

/// \brief An efficient algorithm for finding a minimum cost maximum flow.

#include <lemon/preflow.h>

#include <lemon/network_simplex.h>

#include <lemon/maps.h>

namespace lemon {

  /// \addtogroup min_cost_flow

  /// @{

  /// \brief An efficient algorithm for finding a minimum cost

  /// maximum flow.

  ///

  /// \ref MinCostMaxFlow implements an efficient algorithm for

  /// finding a maximum flow having minimal total cost from a given

  /// source node to a given target node in a directed graph.

  ///

  /// \ref MinCostMaxFlow uses \ref Preflow for finding the maximum

  /// flow value and \ref NetworkSimplex for finding a minimum cost

  /// flow of that value.

  /// According to our benchmark tests \ref Preflow is generally the

  /// most efficient algorithm for the maximum flow problem and

  /// \ref NetworkSimplex is the most efficient for the minimum cost

  /// flow problem in LEMON.

  ///

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

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

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

  ///

  /// \warning

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

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

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

  ///

  /// \author Peter Kovacs

  template < typename Graph,

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

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

  class MinCostMaxFlow

  {

    GRAPH_TYPEDEFS(typename Graph);

    typedef typename CapacityMap::Value Capacity;

    typedef typename CostMap::Value Cost;

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

    typedef Preflow<Graph, CapacityMap> MaxFlowImpl;

    typedef NetworkSimplex< Graph, CapacityMap, CapacityMap,

                            CostMap, SupplyMap > MinCostFlowImpl;

  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:

    // The directed graph the algorithm runs on

    const Graph &_graph;

    // The capacity map

    const CapacityMap &_capacity;

    // The cost map

    const CostMap &_cost;

    // Edge map of the found flow

    FlowMap *_flow;

    bool _local_flow;

    // Node map of the current potentials

    PotentialMap *_potential;

    bool _local_potential;

    // The source node

    Node _source;

    // The target node

    Node _target;

  public:

    /// \brief Constructor.

    ///

    /// Constructor.

    ///

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

    MinCostMaxFlow( const Graph &graph,

                    const CapacityMap &capacity,

                    const CostMap &cost,

                    Node s, Node t ) :

      _graph(graph), _capacity(capacity), _cost(cost), _flow(0),

      _local_flow(false), _potential(0), _local_potential(false),

      _source(s), _target(t) {}

    /// Destructor.

    ~MinCostMaxFlow() {

      if (_local_flow) delete _flow;

      if (_local_potential) delete _potential;

    }

    /// \brief Set the flow map.

    ///

    /// Set the flow map.

    ///

    /// \return \c (*this)

    MinCostMaxFlow& 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)

    MinCostMaxFlow& potentialMap(PotentialMap &map) {

      if (_local_potential) {

        delete _potential;

        _local_potential = false;

      }

      _potential = ↦

      return *this;

    }

    /// \name Execution control

    /// @{

    /// \brief Run the algorithm.

    ///

    /// Run the algorithm.

    void run() {

      // Initializing maps

      if (!_flow) {

        _flow = new FlowMap(_graph);

        _local_flow = true;

      }

      if (!_potential) {

        _potential = new PotentialMap(_graph);

        _local_potential = true;

      }

      // Running Preflow

      MaxFlowImpl preflow(_graph, _capacity, _source, _target);

      preflow.flowMap(*_flow).runMinCut();

      // Running NetworkSimplex

      MinCostFlowImpl mcf( _graph, _capacity, _cost,

                           _source, _target, preflow.flowValue() );

      mcf.flowMap(*_flow).potentialMap(*_potential).run();

    }

    /// @}

    /// \name Query Functions

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

    /// functions.\n

    /// \ref lemon::MinCostMaxFlow::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;

    }

    /// @}

  }; //class MinCostMaxFlow

  ///@}

} //namespace lemon

#endif //LEMON_MIN_COST_MAX_FLOW_H