/// \brief Maximum flows.

 /// \brief Maximum flow algorithms.

   /// \addtogroup galgs

   //  ///\author Marton Makai, Jacint Szabo

   /// @{                                                                                                                                        

   /// A class for computing max flows and related quantities.

   ///Maximum flow algorithms class.

   /// \ingroup galgs

   ///This class provides various algorithms for finding a flow of

   ///maximum value in a directed graph. The \e source node, the \e

   ///target node, the \e capacity of the edges and the \e starting \e

   ///flow value of the edges can be passed to the algorithm through the

   ///constructor. It is possible to change these quantities using the

   ///functions \ref resetSource, \ref resetTarget, \ref resetCap and

   ///\ref resetFlow. Before any subsequent runs of any algorithm of

   ///the class \ref resetFlow should be called, otherwise it will

   ///start from a maximum flow.                                                                                                                 

   ///After running an algorithm of the class, the maximum value of a

   ///value can be obtained by calling \ref flowValue(). The minimum

   ///value cut can be written into a \c node map of \c bools by

   ///calling \ref minCut. (\ref minMinCut and \ref maxMinCut writes

   ///the inclusionwise minimum and maximum of the minimum value

   ///cuts, resp.)                                                                                                                               

   ///\param Graph The undirected graph type the algorithm runs on.

   ///\param Num The number type of the capacities and the flow values.

   ///\param CapMap The type of the capacity map.

   ///\param FlowMap The type of the flow map.                                                                                                           

   ///\author Marton Makai, Jacint Szabo 

     //level works as a bool map in augmenting path algorithms

     //and is used by bfs for storing reached information.

     //excess is needed only in preflow

     //In preflow, it shows levels of nodes.

     //typename Graph::template NodeMap<int> level;

     //   protected:

     //fixme    

 //   protected:

     ///\todo Document this.

     ///Indicates the property of the starting flow.

     ///\todo Maybe, it should be PRE_FLOW instead.

     ///- \c NO_FLOW means nothing,

     ///Indicates the property of the starting flow. The meanings are as follows:

     ///- \c ZERO_FLOW means something,

     ///- \c ZERO_FLOW: constant zero flow

     ///- \c GEN_FLOW means something else,

     ///- \c GEN_FLOW: any flow, i.e. the sum of the in-flows equals to

     ///- \c PRE_FLOW is something different.

     ///the sum of the out-flows in every node except the \e source and

     ///the \e target.

     ///- \c PRE_FLOW: any preflow, i.e. the sum of the in-flows is at 

     ///least the sum of the out-flows in every node except the \e source.

     ///- \c NO_FLOW: indicates an unspecified edge map. \ref flow will be 

     ///set to the constant zero flow in the beginning of the algorithm in this case.

     /// A max flow algorithm is run.

     ///Runs a maximum flow algorithm.

     /// \pre The flow have to satisfy the requirements

     /// stated in fe.

     ///Runs a preflow algorithm, which is the fastest maximum flow

     ///algorithm up-to-date. The default for \c fe is ZERO_FLOW.

     ///\pre The starting flow must be

     /// - a constant zero flow if \c fe is \c ZERO_FLOW,

     /// - an arbitary flow if \c fe is \c GEN_FLOW,

     /// - an arbitary preflow if \c fe is \c PRE_FLOW,

     /// - any map if \c fe is NO_FLOW.

     /// A preflow algorithm is run.

     /// \pre The initial edge-map have to be a

     ///Runs a preflow algorithm.  

     /// zero flow if \c fe is \c ZERO_FLOW,

     /// a flow if \c fe is \c GEN_FLOW,

     ///Runs a preflow algorithm. The preflow algorithms provide the

     /// a pre-flow if fe is \c PRE_FLOW and

     ///fastest way to compute a maximum flow in a directed graph.

     /// anything if fe is NO_FLOW.

     ///\pre The starting flow must be

     /// - a constant zero flow if \c fe is \c ZERO_FLOW,

     /// - an arbitary flow if \c fe is \c GEN_FLOW,

     /// - an arbitary preflow if \c fe is \c PRE_FLOW,

     /// - any map if \c fe is NO_FLOW.

       preflowPhase0(fe);

       preflowPhase1(fe);

       preflowPhase1();

       preflowPhase2();

     }

     }

     // Heuristics:

     /// Run the first phase of preflow, starting from a 0 flow, from a flow,

     //   2 phase

     /// or from a preflow, of from undefined value according to \c fe.

     //   gap

     void preflowPhase0(flowEnum fe);

     //   list 'level_list' on the nodes on level i implemented by hand

     //   stack 'active' on the active nodes on level i                                                                                    

     /// Second phase of preflow.

     //   runs heuristic 'highest label' for H1*n relabels

     void preflowPhase1();

     //   runs heuristic 'bound decrease' for H0*n relabels, starts with 'highest label'

     //   Parameters H0 and H1 are initialized to 20 and 1.

     ///Runs the first phase of the preflow algorithm.

     ///The preflow algorithm consists of two phases, this method runs the

     ///first phase. After the first phase the maximum flow value and a

     ///minimum value cut can already be computed, though a maximum flow

     ///is net yet obtained. So after calling this method \ref flowValue

     ///and \ref actMinCut gives proper results.

     ///\warning: \ref minCut, \ref minMinCut and \ref maxMinCut do not

     ///give minimum value cuts unless calling \ref preflowPhase2.

     ///\pre The starting flow must be

     /// - a constant zero flow if \c fe is \c ZERO_FLOW,

     /// - an arbitary flow if \c fe is \c GEN_FLOW,

     /// - an arbitary preflow if \c fe is \c PRE_FLOW,

     /// - any map if \c fe is NO_FLOW.

     void preflowPhase1( flowEnum fe );

     ///Runs the second phase of the preflow algorithm.

     ///The preflow algorithm consists of two phases, this method runs

     ///the second phase. After calling \ref preflowPhase1 and then

     ///\ref preflowPhase2 the methods \ref flowValue, \ref minCut,

     ///\ref minMinCut and \ref maxMinCut give proper results.

     ///\pre \ref preflowPhase1 must be called before.

     void preflowPhase2();

     /// Returns the actual flow value.

     /// Returns the maximum value of a flow.

     /// More precisely, it returns the negative excess of s, thus

     /// this works also for preflows.

     /// Returns the maximum value of a flow, by counting the 

     /// over-flow of the target node \ref t.

     /// It can be called already after running \ref preflowPhase1.

     }

       //marci figyu: excess[t] epp ezt adja preflow 1. fazisa utan   

     }

     /// Should be used between preflowPhase0 and preflowPhase1.

     ///Returns a minimum value cut after calling \ref preflowPhase1.

     ///After the first phase of the preflow algorithm the maximum flow

     ///value and a minimum value cut can already be computed. This

     ///method can be called after running \ref preflowPhase1 for

     ///obtaining a minimum value cut.

     /// \warning Gives proper result only right after calling \ref

     /// preflowPhase1.

     /// The unique inclusionwise minimum cut is computed by

     ///Returns the inclusionwise minimum of the minimum value cuts.

     /// processing a bfs from s in the residual graph.

     /// \pre flow have to be a max flow otherwise it will the whole node-set.

     ///Sets \c M to the characteristic vector of the minimum value cut

     ///which is inclusionwise minimum. It is computed by processing

     ///a bfs from the source node \c s in the residual graph.

     ///\pre M should be a node map of bools initialized to false.

     ///\pre \c flow must be a maximum flow.

     ///Returns the inclusionwise maximum of the minimum value cuts.

     /// The unique inclusionwise maximum cut is computed by

     /// processing a reverse bfs from t in the residual graph.

     ///Sets \c M to the characteristic vector of the minimum value cut

     /// \pre flow have to be a max flow otherwise it will be empty.

     ///which is inclusionwise maximum. It is computed by processing a

     ///backward bfs from the target node \c t in the residual graph.

     ///\pre M should be a node map of bools initialized to false.

     ///\pre \c flow must be a maximum flow. 

     ///Returns a minimum value cut.

     /// A minimum cut is computed.

     ///Sets \c M to the characteristic vector of a minimum value cut.

     ///\pre M should be a node map of bools initialized to false.

     ///\pre \c flow must be a maximum flow.    

     ///

     ///Resets the source node to \c _s.

     ///Resets the source node to \c _s.

     /// 

     /// capacity-map is changed.

     /// Resets the edge map of the capacities to _cap.

     /// Resets the edge map of the capacities to _cap.

     /// 

     /// flow-map is changed.

     /// Resets the edge map of the flows to _flow.

     /// Resets the edge map of the flows to _flow.

     /// 

   void MaxFlow<Graph, Num, CapMap, FlowMap>::preflowPhase0( flowEnum fe )

   void MaxFlow<Graph, Num, CapMap, FlowMap>::preflowPhase1( flowEnum fe )

     switch (fe) {

     if ( fe == NO_FLOW ) {

       EdgeIt e;

       for(g->first(e); g->valid(e); g->next(e)) flow->set(e,0);

     }

     switch (fe) { //computing the excess

 	//computing the excess of t

 	NodeIt v;

 	for(g->first(v); g->valid(v); g->next(v)) excess.set(v,0);

     default:;

     case ZERO_FLOW:

     case NO_FLOW:

       {

 	NodeIt v;

         for(g->first(v); g->valid(v); g->next(v)) excess.set(v,0);

 	break;

       }

   void MaxFlow<Graph, Num, CapMap, FlowMap>::preflowPhase1()

   void MaxFlow<Graph, Num, CapMap, FlowMap>::preflowPhase2()