/* -*- C++ -*-
 *
 * This file is a part of LEMON, a generic C++ optimization library
 *
 * Copyright (C) 2003-2006
 * 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_CSP_H
#define LEMON_CSP_H

///\ingroup flowalgs
///\file
///\brief Algorithm for the Resource Constrained Shortest Path problem.
///
///
///\todo dijkstraZero() solution should be revised.

#include <lemon/list_graph.h>
#include <lemon/graph_utils.h>
#include <lemon/error.h>
#include <lemon/maps.h>
#include <lemon/tolerance.h>
#include <lemon/dijkstra.h>
#include <lemon/path.h>
#include <lemon/counter.h>
namespace lemon {
  
  ///Algorithms for the Resource Constrained Shortest Path Problem
  
  ///\e
  ///
  template<class Graph,
	   class CM=typename Graph:: template EdgeMap<double>,
	   class DM=CM>
  class ConstrainedShortestPath 
  {
  public:
    
    GRAPH_TYPEDEFS(typename Graph);
    
    typedef SimplePath<Graph> Path;
    
    Graph &_g;
    Tolerance<double> tol;

    CM &_cost;
    DM &_delay;

    class CoMap 
    {
      CM &_cost;
      DM &_delay;
      double _lambda;
    public:
      typedef typename CM::Key Key;
      typedef double Value;
      CoMap(CM &c,DM &d) :_cost(c), _delay(d), _lambda(0) {}
      double lambda() const { return _lambda; }
      void lambda(double l)  { _lambda=l; }
      Value operator[](Key &e) const 
      {
	return _cost[e]+_lambda*_delay[e];
      }
    } _co_map;
    
    
    Dijkstra<Graph, CoMap> _dij;
    ///\e
    
    ///\e
    ///
    ConstrainedShortestPath(Graph &g, CM &cost, DM &delay)
      : _g(g), _cost(cost), _delay(delay),
	_co_map(cost,delay), _dij(_g,_co_map) {}
    

    ///Compute the cost of a path
    double cost(const Path &p) 
    {
      double s=0;
      //      Path r;  
      for(typename Path::EdgeIt e(p);e!=INVALID;++e) s+=_cost[e];
      return s;
    }

    ///Compute the delay of a path
    double delay(const Path &p) 
    {
      double s=0;
      for(typename Path::EdgeIt e(p);e!=INVALID;++e) s+=_delay[e];
      return s;
    }
    
    ///Runs the LARAC algorithm
    
    ///This function runs a Lagrange relaxation based heuristic to find
    ///a delay constrained least cost path.
    ///\param s source node
    ///\param t target node
    ///\retval lo_bo a lower bound on the optimal solution
    ///\return the found path or an empty 
    Path larac(Node s, Node t, double delta, double &lo_bo) 
    {
      NoCounter cnt("LARAC iterations: ");
      double lambda=0;
      double cp,cq,dp,dq,cr,dr;
      Path p;
      Path q;
      Path r;
      {
	Dijkstra<Graph,CM> dij(_g,_cost);
	dij.run(s,t);
	cnt++;
	if(!dij.reached(t)) return Path();
	p=dij.path(t);
	cp=cost(p);
	dp=delay(p);
      }
      if(delay(p)<=delta) return p;
      {
	Dijkstra<Graph,DM> dij(_g,_delay);
	dij.run(s,t);
	cnt++;
	q=dij.path(t);
	cq=cost(q);
	dq=delay(q);
      }
      if(delay(q)>delta) return Path();
      while (true) {
	lambda=(cp-cq)/(dq-dp);
	_co_map.lambda(lambda);
	_dij.run(s,t);
	cnt++;
	r=_dij.path(t);
	cr=cost(r);
	dr=delay(r);
	if(!tol.less(cr+lambda*dr,cp+lambda*dp)) {
	  lo_bo=cq+lambda*(dq-delta);
	  return q;
	}
	else if(tol.less(dr,delta)) 
	  {
	    q=r;
	    cq=cr;
	    dq=dr;
	  }
	else if(tol.less(delta,dr))
	  {
	    p=r;
	    cp=cr;
	    dp=dr;
	  }
	else return r;
      }
    }
  };
  

} //END OF NAMESPACE LEMON

#endif