/// \brief %Hao-Orlin algorithm for calculate minimum cut in directed graphs.

   /// \brief %Hao-Orlin algorithm to find a minimum cut in directed graphs.

   /// Hao-Orlin calculates the minimum cut in directed graphs. It

   /// Hao-Orlin calculates a minimum cut in a directed graph \f$

   /// separates the nodes of the graph into two disjoint sets, 

   /// D=(V,A) \f$. It takes a fixed node \f$ source \in V \f$ and consists

   /// \f$ V_{out} \f$ and \f$ V_{in} \f$. This separation is the minimum

   /// of two phases: in the first phase it determines a minimum cut

   /// cut if the summary of the edge capacities which source is in

   /// with \f$ source \f$ on the source-side (i.e. a set \f$ X\subsetneq V

   /// \f$ V_{out} \f$ and the target is in \f$ V_{in} \f$ is the

   /// \f$ with \f$ source \in X \f$ and minimal out-degree) and in the

   /// minimum.  The algorithm is a modified push-relabel preflow

   /// second phase it determines a minimum cut with \f$ source \f$ on the

   /// algorithm and it calculates the minimum cut in \f$ O(n^3) \f$

   /// sink-side (i.e. a set \f$ X\subsetneq V \f$ with \f$ source \notin X \f$

   /// time. The purpose of such algorithm is testing network

   /// and minimal out-degree). Obviously, the smaller of these two

   /// reliability. For sparse undirected graph you can use the

   /// cuts will be a minimum cut of \f$ D \f$. The algorithm is a

   /// algorithm of Nagamochi and Ibaraki which solves the undirected

   /// modified push-relabel preflow algorithm and our implementation

   /// problem in \f$ O(ne + n^2 \log(n)) \f$ time and it is implemented in the

   /// calculates the minimum cut in \f$ O(n^3) \f$ time (we use the

   /// MinCut algorithm class.

   /// highest-label rule). The purpose of such an algorithm is testing

   /// network reliability. For an undirected graph with \f$ n \f$

   /// nodes and \f$ e \f$ edges you can use the algorithm of Nagamochi

   /// and Ibaraki which solves the undirected problem in \f$ O(ne +

   /// n^2 \log(n)) \f$ time: it is implemented in the MinCut algorithm

   /// class.

   /// default type for it is Tolerance<typename CapacityMap::Value>.

   /// default type for this is Tolerance<typename CapacityMap::Value>.

     /// for the algorithm. The \c source node is used as the push-relabel

     /// for the algorithm. Node \c source  is used as the push-relabel

     /// \brief Calculates the minimum cut with the \c source node

     /// \brief Calculates a minimum cut with \f$ source \f$ on the

     /// in the \f$ V_{out} \f$.

     /// source-side.

     ///

     ///

     /// Calculates the minimum cut with the \c source node

     /// \brief Calculates a minimum cut with \f$ source \f$ on the

     /// in the \f$ V_{out} \f$.

     /// source-side (i.e. a set \f$ X\subsetneq V \f$ with \f$ source \in X

     /// \f$ and minimal out-degree).

     /// \brief Calculates the minimum cut with the \c source node

     /// \brief Calculates a minimum cut with \f$ source \f$ on the

     /// in the \f$ V_{out} \f$.

     /// source-side.

     ///

     ///

     /// Calculates the minimum cut with the \c source node

     /// \brief Calculates a minimum cut with \f$ source \f$ on the

     /// in the \f$ V_{out} \f$. The \c target is the initial target

     /// source-side (i.e. a set \f$ X\subsetneq V \f$ with \f$ source \in X

     /// \f$ and minimal out-degree). The \c target is the initial target

     /// \brief Calculates the minimum cut with the \c source node

     /// \brief Calculates a minimum cut with \f$ source \f$ on the

     /// in the \f$ V_{in} \f$.

     /// sink-side.

     ///

     ///

     /// Calculates the minimum cut with the \c source node

     /// \brief Calculates a minimum cut with \f$ source \f$ on the

     /// in the \f$ V_{in} \f$.

     /// sink-side (i.e. a set \f$ X\subsetneq V \f$ with \f$ source \notin X

     /// \f$ and minimal out-degree).

     /// \brief Calculates the minimum cut with the \c source node

     /// \brief Calculates a minimum cut with \f$ source \f$ on the

     /// in the \f$ V_{in} \f$.

     /// sink-side.

     ///

     ///

     /// Calculates the minimum cut with the \c source node

     /// \brief Calculates a minimum cut with \f$ source \f$ on the

     /// in the \f$ V_{in} \f$. The \c target is the initial target

     /// sink-side (i.e. a set \f$ X\subsetneq V \f$ with \f$ source \notin

     /// for the push-relabel algorithm.

     /// X \f$ and minimal out-degree).  The \c target is the initial

     /// target for the push-relabel algorithm.

     /// Runs the algorithm. It finds a proper \c source and \c target

     /// Runs the algorithm. It finds nodes \c source and \c target

     /// and then calls the \ref init(), \ref calculateOut() and \ref

     /// arbitrarily and then calls \ref init(), \ref calculateOut()

     /// calculateIn().

     /// and \ref calculateIn().

     /// Runs the algorithm. It finds a proper \c target and then calls

     /// Runs the algorithm. It uses the given \c source node, finds a

     /// the \ref init(), \ref calculateOut() and \ref calculateIn().

     /// proper \c target and then calls the \ref init(), \ref

     /// calculateOut() and \ref calculateIn().

     /// \brief Returns a minimum value cut.

     /// \brief Returns a minimum cut.

     /// value cut. The nodes in \f$ V_{out} \f$ will be set true and

     /// value cut: it will give a nonempty set \f$ X\subsetneq V \f$

     /// the nodes in \f$ V_{in} \f$ will be set false. 

     /// with minimal out-degree (i.e. \c nodeMap will be true exactly

     /// \pre nodeMap should be a bool-valued node-map.

     /// for the nodes of \f$ X \f$.  \pre nodeMap should be a

     /// bool-valued node-map.