// -*- mode:c++ -*-

 #ifndef EDMONDS_KARP_HH

 #define EDMONDS_KARP_HH

 #include <queue>

 //#include <marci_property_vector.hh>

 #include <algorithm>

 //#include <bfs_iterator.hh>

 namespace lemon {

   template <typename Graph, typename FlowMap, typename CapacityMap>

   typename FlowMap::Value maxFlow(Graph &G,

 				      FlowMap &f,

 				      CapacityMap &c,

 				      typename Graph::NodeIt s,

 				      typename Graph::NodeIt t)

   { 

     typedef typename Graph::NodeIt NodeIt;

     typedef typename Graph::EachNodeIt EachNodeIt;

     typedef typename Graph::EdgeIt EdgeIt;

     typedef typename Graph::EachEdgeIt EachEdgeIt;

     typedef typename Graph::OutEdgeIt OutEdgeIt;

     typedef typename Graph::InEdgeIt InEdgeIt;

     typedef typename FlowMap::Value T;

     T flow_val = 0;

     T aug_val;

     for(EachEdgeIt e(G);G.valid(e);G.goNext(e))

       f.set(e,0);

     std::queue<NodeIt> bfs_queue;

     typename Graph::NodeMap<int> visited(G); //0: unvisited,

                                              //1: reached by a forward edge

                                              //2: reached by a backward edge

                                              //3: it is node s

     typename Graph::NodeMap<EdgeIt> tree(G);

     NodeIt gn;  //FIXME: it might be too global for some people...

   augment:

     for(EachNodeIt n(G);G.valid(n);G.goNext(n))

       visited.set(n,0);

     visited.set(s,3);

     //There must be a better way to do this:

     while(!bfs_queue.empty()) bfs_queue.pop();

     bfs_queue.push(s);

     while(!bfs_queue.empty() && !visited.get(t))

       {

 	NodeIt n(bfs_queue.front());

 	bfs_queue.pop();

 	for(OutEdgeIt e(G,n);G.valid(e);G.goNext(e))

 	  if(f.get(e)<c.get(e) &&   //FIXME: <

 	     !visited.get(G.bNode(e))) 

 	    {

 	      NodeIt nn(G.bNode(e)); //It improves nothing

 	      tree.set(nn,e);

 	      visited.set(nn,1);

 	      bfs_queue.push(nn);

 	    }

 	for(InEdgeIt e(G,n);G.valid(e);G.goNext(e))

 	  if(f.get(e)>0 &&   //FIXME: >

 	     !visited.get(G.bNode(e))) 

 	    {

 	      NodeIt nn(G.bNode(e));

 	      tree.set(nn,e);

 	      visited.set(nn,2);

 	      bfs_queue.push(nn);

 	    }

       }

     if(!visited.get(t)) return flow_val;

     // Augmenting value computation

     aug_val = visited.get(t)==1 ?

       c.get(tree.get(t))-f.get(tree.get(t)) : f.get(tree.get(t));

     //FIXME: I would need 'G.opposite(e,n)'

     gn = visited.get(t)==1 ? G.source(tree.get(t)) : G.target(tree.get(t));

     while(gn!=s) if(visited.get(gn)==1)

       {

 	//FIXME: nonstandard gcc extension!

 	aug_val <?= c.get(tree.get(gn))-f.get(tree.get(gn));

 	gn=G.source(tree.get(gn));

       }

     else {

       //FIXME: nonstandard gcc extension!

       aug_val <?= f.get(tree.get(gn));

       gn=G.target(tree.get(gn));

     }

     // The augmentation itself

     gn = t;

     while(gn!=s) if(visited.get(gn)==1)

       {

 	f.set(tree.get(gn),f.get(tree.get(gn))+aug_val);

 	gn=G.source(tree.get(gn));

       }

     else {

       f.set(tree.get(gn),f.get(tree.get(gn))-aug_val);

       gn=G.target(tree.get(gn));

     }

     flow_val+=aug_val;

     goto augment;   // Vivat goto forever!

   }

 } // namespace lemon

 #endif //EDMONDS_KARP_HH