/* -*- 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_SSP_MIN_COST_FLOW_H
#define LEMON_SSP_MIN_COST_FLOW_H

///\ingroup min_cost_flow 
///
///\file
///\brief An algorithm for finding a flow of value \c k (for
///small values of \c k) having minimal total cost


#include <lemon/dijkstra.h>
#include <lemon/graph_adaptor.h>
#include <lemon/maps.h>
#include <vector>

namespace lemon {

  /// \addtogroup min_cost_flow
  /// @{

  /// \brief Implementation of an algorithm for finding a flow of
  /// value \c k (for small values of \c k) having minimal total cost
  /// between two nodes
  /// 
  ///
  /// The \ref lemon::SspMinCostFlow "Successive Shortest Path Minimum
  /// Cost Flow" implements an algorithm for finding a flow of value
  /// \c k having minimal total cost from a given source node to a
  /// given target node in a directed graph with a cost function on
  /// the edges. To this end, the edge-capacities and edge-costs have
  /// to be nonnegative.  The edge-capacities should be integers, but
  /// the edge-costs can be integers, reals or of other comparable
  /// numeric type.  This algorithm is intended to be used only for
  /// small values of \c k, since it is only polynomial in k, not in
  /// the length of k (which is log k): in order to find the minimum
  /// cost flow of value \c k it finds the minimum cost flow of value
  /// \c i for every \c i between 0 and \c k.
  ///
  ///\param Graph The directed graph type the algorithm runs on.
  ///\param LengthMap The type of the length map.
  ///\param CapacityMap The capacity map type.
  ///
  ///\author Attila Bernath
  template <typename Graph, typename LengthMap, typename CapacityMap>
  class SspMinCostFlow {

    typedef typename LengthMap::Value Length;

    //Warning: this should be integer type
    typedef typename CapacityMap::Value Capacity;
    
    typedef typename Graph::Node Node;
    typedef typename Graph::NodeIt NodeIt;
    typedef typename Graph::Edge Edge;
    typedef typename Graph::OutEdgeIt OutEdgeIt;
    typedef typename Graph::template EdgeMap<int> EdgeIntMap;

    typedef ResGraphAdaptor<const Graph,int,CapacityMap,EdgeIntMap> ResGW;
    typedef typename ResGW::Edge ResGraphEdge;

  protected:

    const Graph& g;
    const LengthMap& length;
    const CapacityMap& capacity;

    EdgeIntMap flow; 
    typedef typename Graph::template NodeMap<Length> PotentialMap;
    PotentialMap potential;

    Node s;
    Node t;
    
    Length total_length;

    class ModLengthMap {   
      typedef typename Graph::template NodeMap<Length> NodeMap;
      const ResGW& g;
      const LengthMap &length;
      const NodeMap &pot;
    public :
      typedef typename LengthMap::Key Key;
      typedef typename LengthMap::Value Value;

      ModLengthMap(const ResGW& _g, 
		   const LengthMap &_length, const NodeMap &_pot) : 
	g(_g), /*rev(_rev),*/ length(_length), pot(_pot) { }
	
      Value operator[](typename ResGW::Edge e) const {     
	if (g.forward(e))
	  return  length[e]-(pot[g.target(e)]-pot[g.source(e)]);   
	else
	  return -length[e]-(pot[g.target(e)]-pot[g.source(e)]);   
      }     
	
    }; //ModLengthMap

    ResGW res_graph;
    ModLengthMap mod_length;
    Dijkstra<ResGW, ModLengthMap> dijkstra;

  public :

    /// \brief The constructor of the class.
    ///
    /// \param _g The directed graph the algorithm runs on. 
    /// \param _length The length (cost) of the edges. 
    /// \param _cap The capacity of the edges. 
    /// \param _s Source node.
    /// \param _t Target node.
    SspMinCostFlow(Graph& _g, LengthMap& _length, CapacityMap& _cap, 
                   Node _s, Node _t) : 
      g(_g), length(_length), capacity(_cap), flow(_g), potential(_g), 
      s(_s), t(_t), 
      res_graph(g, capacity, flow), 
      mod_length(res_graph, length, potential),
      dijkstra(res_graph, mod_length) { 
      reset();
    }
    
    /// \brief Tries to augment the flow between s and t by 1. The
    /// return value shows if the augmentation is successful.
    bool augment() {
      dijkstra.run(s);
      if (!dijkstra.reached(t)) {

	//Unsuccessful augmentation.
	return false;
      } else {

	//We have to change the potential
	for(typename ResGW::NodeIt n(res_graph); n!=INVALID; ++n)
	  potential.set(n, potential[n]+dijkstra.distMap()[n]);
	
	//Augmenting on the shortest path
	Node n=t;
	ResGraphEdge e;
	while (n!=s){
	  e = dijkstra.predEdge(n);
	  n = dijkstra.predNode(n);
	  res_graph.augment(e,1);
	  //Let's update the total length
	  if (res_graph.forward(e))
	    total_length += length[e];
	  else 
	    total_length -= length[e];	    
	}

	return true;
      }
    }
    
    /// \brief Runs the algorithm.
    ///
    /// Runs the algorithm.
    /// Returns k if there is a flow of value at least k from s to t.
    /// Otherwise it returns the maximum value of a flow from s to t.
    ///
    /// \param k The value of the flow we are looking for.
    ///
    /// \todo May be it does make sense to be able to start with a
    /// nonzero feasible primal-dual solution pair as well.
    ///
    /// \todo If the current flow value is bigger than k, then
    /// everything is cleared and the algorithm starts from zero
    /// flow. Is it a good approach?
    int run(int k) {
      if (flowValue()>k) reset();
      while (flowValue()<k && augment()) { }
      return flowValue();
    }

    /// \brief The class is reset to zero flow and potential.
    void reset() {
      total_length=0;
      for (typename Graph::EdgeIt e(g); e!=INVALID; ++e) flow.set(e, 0);
      for (typename Graph::NodeIt n(g); n!=INVALID; ++n) potential.set(n, 0);  
    }

    /// \brief Returns the value of the current flow. 
    int flowValue() const {
      int i=0;
      for (typename Graph::OutEdgeIt e(g, s); e!=INVALID; ++e) i+=flow[e];
      for (typename Graph::InEdgeIt e(g, s); e!=INVALID; ++e) i-=flow[e];
      return i;
    }

    /// \brief Total cost of the found flow.
    ///
    /// This function gives back the total cost of the found flow.
    Length totalLength(){
      return total_length;
    }

    /// \brief Returns a const reference to the EdgeMap \c flow. 
    ///
    /// Returns a const reference to the EdgeMap \c flow. 
    const EdgeIntMap &getFlow() const { return flow;}

    /// \brief Returns a const reference to the NodeMap \c potential
    /// (the dual solution).
    ///
    /// Returns a const reference to the NodeMap \c potential (the
    /// dual solution).
    const PotentialMap &getPotential() const { return potential;}

    /// \brief Checking the complementary slackness optimality criteria.
    ///
    /// This function checks, whether the given flow and potential 
    /// satisfy the complementary slackness conditions (i.e. these are optimal).
    /// This function only checks optimality, doesn't bother with feasibility.
    /// For testing purpose.
    bool checkComplementarySlackness(){
      Length mod_pot;
      Length fl_e;
        for(typename Graph::EdgeIt e(g); e!=INVALID; ++e) {
	//C^{\Pi}_{i,j}
	mod_pot = length[e]-potential[g.target(e)]+potential[g.source(e)];
	fl_e = flow[e];
	if (0<fl_e && fl_e<capacity[e]) {
	  /// \todo better comparison is needed for real types, moreover, 
	  /// this comparison here is superfluous.
	  if (mod_pot != 0)
	    return false;
	} 
	else {
	  if (mod_pot > 0 && fl_e != 0)
	    return false;
	  if (mod_pot < 0 && fl_e != capacity[e])
	    return false;
	}
      }
      return true;
    }
    
  }; //class SspMinCostFlow

  ///@}

} //namespace lemon

#endif //LEMON_SSP_MIN_COST_FLOW_H