RhodeCode

  /// value cut in a directed graph \f$D=(V,A)\f$.

  /// It takes a fixed node \f$ source \in V \f$ and

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

  /// minimum cut with \f$ source \f$ on the source-side (i.e. a set

  /// \f$ X\subsetneq V \f$ with \f$ source \in X \f$ and minimal outgoing

  /// capacity) and in the second phase it determines a minimum cut

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

  /// \f$ X\subsetneq V \f$ with \f$ source \notin X \f$ and minimal outgoing

  /// capacity). Obviously, the smaller of these two cuts will be a

  /// minimum cut of \f$ D \f$. The algorithm is a modified

  /// preflow push-relabel algorithm. Our implementation calculates

  /// the minimum cut in \f$ O(n^2\sqrt{m}) \f$ time (we use the

  ///

  /// For an undirected graph you can run just the first phase of the

  /// algorithm or you can use the algorithm of Nagamochi and Ibaraki,

  /// which solves the undirected problem in \f$ O(nm + n^2 \log n) \f$

  /// time. It is implemented in the NagamochiIbaraki algorithm class.

  ///

  /// \tparam GR The type of the digraph the algorithm runs on.

  /// \tparam CAP The type of the arc map containing the capacities,

  /// which can be any numreric type. The default map type is

  /// \ref concepts::Digraph::ArcMap "GR::ArcMap<int>".

  /// \tparam TOL Tolerance class for handling inexact computations. The

  /// default tolerance type is \ref Tolerance "Tolerance<CAP::Value>".

      }

      _min_cut = std::numeric_limits<Value>::max();

    }

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

    /// source-side.

    ///

    /// This function calculates a minimum cut with \f$ source \f$ on the

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

    /// \f$ source \in X \f$ and minimal outgoing capacity).

    ///

    /// \pre \ref init() must be called before using this function.

    void calculateOut() {

      findMinCutOut();

    }

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

    /// sink-side.

    ///

    /// This function calculates a minimum cut with \f$ source \f$ on the

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

    /// \f$ source \notin X \f$ and minimal outgoing capacity).

    ///

    /// \pre \ref init() must be called before using this function.

    void calculateIn() {

      findMinCutIn();

    }

    /// \brief Run the algorithm.

    ///

    /// and \ref calculateIn().

    void run() {

      init();

      calculateOut();

      calculateIn();

    }

    /// \brief Run the algorithm.

    ///

    void run(const Node& s) {

      init(s);

      calculateOut();

      calculateIn();

    }

    /// @}

    /// \name Query Functions

    /// The result of the %HaoOrlin algorithm

    /// can be obtained using these functions.\n

    /// \ref run(), \ref calculateOut() or \ref calculateIn()

    /// should be called before using them.

    /// @{

    /// \brief Return the value of the minimum cut.

    ///

    ///

    /// \pre \ref run(), \ref calculateOut() or \ref calculateIn()

    /// must be called before using this function.

    Value minCutValue() const {

      return _min_cut;

    }

    /// \brief Return a minimum cut.

    ///

    /// for the nodes of \f$ X \f$).

    ///

    /// \param cutMap A \ref concepts::WriteMap "writable" node map with

    /// \c bool (or convertible) value type.

    ///

    /// \return The value of the minimum cut.

    ///

    /// \pre \ref run(), \ref calculateOut() or \ref calculateIn()

    /// must be called before using this function.

    template <typename CutMap>

    Value minCutMap(CutMap& cutMap) const {

      for (NodeIt it(_graph); it != INVALID; ++it) {