RhodeCode

  /// The Gomory-Hu tree is a tree on the node set of the graph, but it

  /// may contain edges which are not in the original digraph. It has the

  /// in this tree has the same weight as the minimum cut in the digraph

  /// the minimum cut and the minimum cut value between any two node

  /// in the digraph. You can also list (iterate on) the nodes and the

  /// edges of the cuts using MinCutNodeIt and MinCutEdgeIt.

  /// \tparam GR The undirected graph data structure the algorithm will run on

  /// \tparam CAP type of the EdgeMap describing the Edge capacities.

  /// it is typename GR::template EdgeMap<int> by default.

	    typename CAP = typename GR::template EdgeMap<int>

            >

    /// The type if the edge capacity map

    /// \param graph The graph the algorithm will run on.

    /// \param capacity The capacity map.

    // \brief Initialize the internal data structures.

    //

    // This function initializes the internal data structures.

    //

    // \brief Start the algorithm

    //

    // This function starts the algorithm.

    //

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

    //

    ///The \ref run() "run()" should be called before using them.\n

    ///See also MinCutNodeIt and MinCutEdgeIt

    /// tree and calculates the minimum weight arc on the paths to

    /// the \r cutMap parameter by setting the nodes in the component of

    /// \c \s to true and the other nodes to false.

    /// The \c cutMap should be \ref concepts::ReadWriteMap

    /// "ReadWriteMap".

    ///

    /// For higher level interfaces, see MinCutNodeIt and MinCutEdgeIt

    Value minCutMap(const Node& s, ///< Base node

                    ///< The node you want to separate from Node s.

                    ///< The cut will be return in this map.

                    /// It must be a \c bool \ref concepts::ReadWriteMap

                    /// "ReadWriteMap" on the graph nodes.

    /// int sum=0;

    /// for(GomoruHu<Graph>::MinCutNodeIt n(gom,s,t);n!=INVALID;++n) ++sum;

      /// Constructor

                   ///  before initializing this iterator

                   const Node& s, ///< Base node

                   ///< The node you want to separate from Node s.

      /// Conversion to Node

      /// Conversion to Node

      /// Next node

      /// Postfix incrementation

      /// returns a \c Node, not a \ref MinCutNodeIt, as one may

    /// for(GomoruHu<Graph>::MinCutEdgeIt e(gom,s,t);e!=INVALID;++e)

    /// \ref GomoryHu::minCostValue() "gom.minCostValue(s,t)"

                   ///  before initializing this iterator

                   const Node& s,  ///< Base node

                   ///< The node you want to separate from Node s.

      /// Conversion to Arc

      /// Conversion to Arc

      /// Conversion to Edge

      /// Conversion to Edge

      /// Next edge

      /// Postfix incrementation

      /// returns a \c Arc, not a \ref MinCutEdgeIt, as one may

      /// expect.

  ght.init();