/* -*- C++ -*-

 * lemon/preflow_matching.h - Part of LEMON, a generic C++ optimization library

 *

 * Copyright (C) 2005 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_CIRCULATION_H

#define LEMON_CIRCULATION_H

#include <lemon/graph_utils.h>

#include <iostream>

#include <queue>

#include <lemon/tolerance.h>

#include <lemon/elevator.h>

///\ingroup max_flow

///\file

///\brief Push-prelabel algorithm for finding a feasible circulation.

///

namespace lemon {

  ///Preflow algorithm for the Network Circulation Problem.

  ///\ingroup max_flow

  ///This class implements a preflow algorithm

  ///for the Network Circulation Problem.

  ///The exact formulation of this problem is the following.

  /// \f[\sum_{e\in\rho(v)}x(e)-\sum_{e\in\delta(v)}x(e)\leq delta(v)\quad \forall v\in V \f]

  /// \f[ lo(e)\leq x(e) \leq up(e) \quad \forall e\in E \f]

  ///

  template<class Graph,

	   class Value,

	   class FlowMap=typename Graph::template EdgeMap<Value>,

	   class LCapMap=typename Graph::template EdgeMap<Value>,

	   class UCapMap=LCapMap,

	   class DeltaMap=typename Graph::template NodeMap<Value>

	    >

  class Circulation {

    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;

    const Graph &_g;

    int _node_num;

    const LCapMap &_lo;

    const UCapMap &_up;

    const DeltaMap &_delta;

    FlowMap &_x;

    Tolerance<Value> _tol;

    Elevator<Graph,typename Graph::Node> _levels;

    typename Graph::template NodeMap<Value> _excess;

  public:

    ///\e

    Circulation(const Graph &g,const LCapMap &lo,const UCapMap &up,

		const DeltaMap &delta,FlowMap &x) :

      _g(g),

      _node_num(countNodes(g)),

      _lo(lo),_up(up),_delta(delta),_x(x),

      _levels(g,_node_num),

      _excess(g)

    {

    }

  private:

    void addExcess(Node n,Value v)

    {

      if(_tol.positive(_excess[n]+=v))

	{

	  if(!_levels.active(n)) _levels.activate(n);

	}

      else if(_levels.active(n)) _levels.deactivate(n);

    }

    void init() 

    {

      _x=_lo;

      for(NodeIt n(_g);n!=INVALID;++n) _excess[n]=-_delta[n];

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

	{

	  _excess[_g.target(e)]+=_x[e];

	  _excess[_g.source(e)]-=_x[e];

	}

      _levels.initStart();

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

	_levels.initAddItem(n);

      _levels.initFinish();

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

	if(_tol.positive(_excess[n]))

	  _levels.activate(n);

    }

  public:

    ///Check if \c x is a feasible circulation

    template<class FT>

    bool checkX(FT &x) {

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

	if(x[e]<_lo[e]||x[e]>_up[e]) return false;

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

	{

	  Value dif=_delta[n];

	  for(InEdgeIt e(_g,n);e!=INVALID;++e) dif-=x[e];

	  for(OutEdgeIt e(_g,n);e!=INVALID;++e) dif+=x[e];

	  if(_tol.negative(dif)) return false;

	}

      return true;

    };

    ///Check if the default \c x is a feasible circulation

    bool checkX() { return checkX(_x); }

    ///Chech if \c bar is a real barrier

    ///Chech if \c bar is a real barrier

    ///\sa barrier()

    template<class GT>

    bool checkBarrier(GT &bar) 

    {

      Value delta=0;

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

	if(bar[n])

	  delta+=_delta[n];

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

	{

	  Node s=_g.source(e);

	  Node t=_g.target(e);

	  if(bar[s]&&!bar[t]) delta+=_up[e];

	  else if(bar[t]&&!bar[s]) delta-=_lo[e];

	}

      return _tol.negative(delta);

    }  

    ///Chech whether or not the last execution provides a barrier

    ///Chech whether or not the last execution provides a barrier

    ///\sa barrier()

    bool checkBarrier() 

    {

      typename Graph:: template NodeMap<bool> bar(_g);

      barrier(bar);

      return checkBarrier(bar);

    }

    ///Run the algorithm

    ///This function runs the algorithm.

    ///\return This function returns -1 if it found a feasible circulation.

    /// nonnegative values (including 0) mean that no feasible solution is

    /// found. In this case the return value means an "empty level".

    ///

    ///\sa barrier()

    int run() 

    {

      init();

#ifdef LEMON_CIRCULATION_DEBUG

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

	std::cerr<< _levels[n] << ' ';

      std::cerr << std::endl;

#endif      

      Node act;

      Node bact=INVALID;

      Node last_activated=INVALID;

      while((act=_levels.highestActive())!=INVALID) {

	int actlevel=_levels[act];

	int tlevel;

	int mlevel=_node_num;

	Value exc=_excess[act];

	Value fc;

#ifdef LEMON_CIRCULATION_DEBUG

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

	  std::cerr<< _levels[n] << ' ';

	std::cerr << std::endl;

	std::cerr << "Process node " << _g.id(act)

		  << " on level " << actlevel

		  << " with excess " << exc

		  << std::endl;

#endif

	for(OutEdgeIt e(_g,act);e!=INVALID; ++e)

	  if((fc=_up[e]-_x[e])>0)

	    if((tlevel=_levels[_g.target(e)])<actlevel)

	      if(fc<=exc) {

		_x[e]=_up[e];

		addExcess(_g.target(e),fc);

		exc-=fc;

#ifdef LEMON_CIRCULATION_DEBUG

		std::cerr << "  Push " << fc

			  << " toward " << _g.id(_g.target(e)) << std::endl;

#endif

	      }

	      else {

		_x[e]+=exc;

		addExcess(_g.target(e),exc);

		//exc=0;

		_excess[act]=0;

		_levels.deactivate(act);

#ifdef LEMON_CIRCULATION_DEBUG

		std::cerr << "  Push " << exc

			  << " toward " << _g.id(_g.target(e)) << std::endl;

		std::cerr << "  Deactivate\n";

#endif

		goto next_l;

	      }

	    else if(tlevel<mlevel) mlevel=tlevel;

	for(InEdgeIt e(_g,act);e!=INVALID; ++e)

	  if((fc=_x[e]-_lo[e])>0)

	    if((tlevel=_levels[_g.source(e)])<actlevel)

	      if(fc<=exc) {

		_x[e]=_lo[e];

		addExcess(_g.source(e),fc);

		exc-=fc;

#ifdef LEMON_CIRCULATION_DEBUG

		std::cerr << "  Push " << fc

			  << " toward " << _g.id(_g.source(e)) << std::endl;

#endif

	      }

	      else {

		_x[e]-=exc;

		addExcess(_g.source(e),exc);

		//exc=0;

		_excess[act]=0;

		_levels.deactivate(act);

#ifdef LEMON_CIRCULATION_DEBUG

		std::cerr << "  Push " << exc

			  << " toward " << _g.id(_g.source(e)) << std::endl;

		std::cerr << "  Deactivate\n";

#endif

		goto next_l;

              }

	    else if(tlevel<mlevel) mlevel=tlevel;

	_excess[act]=exc;

	if(!_tol.positive(exc)) _levels.deactivate(act);

	else if(mlevel==_node_num) {

	  _levels.liftHighestActiveTo(_node_num);

#ifdef LEMON_CIRCULATION_DEBUG

	  std::cerr << "  Lift to level " << _node_num << std::endl;

#endif

	  return _levels.onLevel(_node_num-1)==0?_node_num-1:actlevel;

	}

	else {

	  _levels.liftHighestActiveTo(mlevel+1);

#ifdef LEMON_CIRCULATION_DEBUG

	  std::cerr << "  Lift to level " << mlevel+1 << std::endl;

#endif

	  if(_levels.onLevel(actlevel)==0)

	    return actlevel;

	}

      next_l:

	;

      }

#ifdef LEMON_CIRCULATION_DEBUG

      std::cerr << "Feasible flow found.\n";

#endif

      return -1;

    }

    ///Return a barrier

    ///Barrier is a set \e B of nodes for which

    /// \f[ \sum_{v\in B}delta(v)<\sum_{e\in\rho(B)}lo(e)-\sum_{e\in\delta(B)}up(e) \f]

    ///holds. The existence of a set with this property prooves that a feasible

    ///flow cannot exists.

    ///\pre The run() must have been executed, and its return value was -1.

    ///\sa checkBarrier()

    ///\sa run()

    template<class GT>

    void barrier(GT &bar,int empty_level=-1) 

    {

      if(empty_level==-1)

	for(empty_level=0;_levels.onLevel(empty_level);empty_level++) ;

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

	bar[n] = _levels[n]>empty_level;

    }  

  };

}

#endif