// -*- C++ -*-

 //ha predecessor az elejen nem invalid, akkor hagyd csak ugy

 //scanned mutatja hogy jo ertek van-e benne vagy szemet

 /* 

  *template <Graph, T, Heap=FibHeap>

  *

  *Constructor: 

  *

  *Dijkstra(Graph G, NodeIt s, Graph::EdgeMap<T> length)

  *

  *

  *Member functions:

  *

  *void run()

  *

  *  The following function should be used after run() was already run.

  *

  *T dist(NodeIt v) : returns the distance from s to v. 

  *   It is 0 if v is not reachable from s.

  *

  *EdgeIt pred(NodeIt v) : returns the last edge 

  *   of a shortest s-v path. Returns an invalid iterator 

  *   if v=s or v is not reachable from s.

  *

  *bool reach(NodeIt v) : true iff v is reachable from s

  *

  */

 #ifndef DIJKSTRA_H

 #define DIJKSTRA_H

 #include <fib_heap.h>

 namespace hugo {

   template <typename Graph, typename T, 

     typename Heap=FibHeap<typename Graph::NodeIt, T, 

     typename Graph::NodeMap<int> > >

     class Dijkstra{

       typedef typename Graph::NodeIt NodeIt;

       typedef typename Graph::EdgeIt EdgeIt;

       typedef typename Graph::OutEdgeIt OutEdgeIt;

       Graph& G;

       NodeIt s;

       typename Graph::NodeMap<EdgeIt> predecessor;

       typename Graph::NodeMap<T> distance;

       typename Graph::EdgeMap<T>& length;

       typename Graph::NodeMap<bool> reached;

   public :

     /*

       The distance of the nodes is 0.

     */

     Dijkstra(Graph& _G, NodeIt const _s, 

 	     typename Graph::EdgeMap<T>& _length) : 

       G(_G), s(_s), predecessor(G), distance(G), 

       length(_length), reached(G, false) { }

       void run() {

 	typename Graph::NodeMap<bool> scanned(G, false);

 	typename Graph::NodeMap<int> heap_map(G,-1);

 	Heap heap(heap_map);

 	heap.push(s,0); 

 	reached.set(s, true);

 	while ( !heap.empty() ) {

 	  NodeIt v=heap.top(); 

 	  T oldvalue=heap.get(v);

 	  heap.pop();

 	  distance.set(v, oldvalue);

 	  scanned.set(v,true);

 	  OutEdgeIt e;

 	  for( G.getFirst(e,v); G.valid(e); G.next(e)) {

 	    NodeIt w=G.bNode(e); 

 	    if ( !scanned.get(w) ) {

 	      if ( !reached.get(w) ) {

 		reached.set(w,true);

 		heap.push(w,oldvalue+length.get(e)); 

 		predecessor.set(w,e);

 	      } else if ( oldvalue+length.get(e) < heap.get(w) ) {

 		predecessor.set(w,e);

 		heap.decrease(w, oldvalue+length.get(e)); 

 	      }

 	    }

 	  }

 	}

       } 

       T dist(NodeIt v) {

 	return distance.get(v);

       }

       EdgeIt pred(NodeIt v) {

 	if ( v!=s ) return predecessor.get(v);

 	else return EdgeIt();

       }

       bool reach(NodeIt v) {

 	return reached.get(v);

       }

     };

 }

 #endif