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