[Lemon-commits] Peter Kovacs: Improvements and fixes for the min...
Lemon HG
hg at lemon.cs.elte.hu
Tue Apr 21 16:33:29 CEST 2009
details: http://lemon.cs.elte.hu/hg/lemon/rev/293551ad254f
changeset: 628:293551ad254f
user: Peter Kovacs <kpeter [at] inf.elte.hu>
date: Wed Apr 15 09:37:51 2009 +0200
description:
Improvements and fixes for the minimum cut algorithms (#264)
diffstat:
lemon/gomory_hu.h | 109 +++++++++++++++++++++---------------
lemon/hao_orlin.h | 158 +++++++++++++++++++++++++++++-----------------------
test/gomory_hu_test.cc | 37 +++++++++++-
test/hao_orlin_test.cc | 148 +++++++++++++++++++++++++++++++++++++++++++------
4 files changed, 317 insertions(+), 135 deletions(-)
diffs (truncated from 723 to 300 lines):
diff --git a/lemon/gomory_hu.h b/lemon/gomory_hu.h
--- a/lemon/gomory_hu.h
+++ b/lemon/gomory_hu.h
@@ -42,24 +42,22 @@
/// in this tree has the same weight as the minimum cut in the graph
/// between these nodes. Moreover the components obtained by removing
/// this edge from the tree determine the corresponding minimum cut.
- ///
/// Therefore once this tree is computed, the minimum cut between any pair
/// of nodes can easily be obtained.
///
/// The algorithm calculates \e n-1 distinct minimum cuts (currently with
- /// the \ref Preflow algorithm), therefore the algorithm has
- /// \f$(O(n^3\sqrt{e})\f$ overall time complexity. It calculates a
- /// rooted Gomory-Hu tree, its structure and the weights can be obtained
- /// by \c predNode(), \c predValue() and \c rootDist().
- ///
- /// The members \c minCutMap() and \c minCutValue() calculate
+ /// the \ref Preflow algorithm), thus it has \f$O(n^3\sqrt{e})\f$ overall
+ /// time complexity. It calculates a rooted Gomory-Hu tree.
+ /// The structure of the tree and the edge weights can be
+ /// obtained using \c predNode(), \c predValue() and \c rootDist().
+ /// The functions \c minCutMap() and \c minCutValue() calculate
/// the minimum cut and the minimum cut value between any two nodes
/// in the graph. You can also list (iterate on) the nodes and the
/// edges of the cuts using \c MinCutNodeIt and \c MinCutEdgeIt.
///
/// \tparam GR The type of the undirected graph the algorithm runs on.
- /// \tparam CAP The type of the edge map describing the edge capacities.
- /// It is \ref concepts::Graph::EdgeMap "GR::EdgeMap<int>" by default.
+ /// \tparam CAP The type of the edge map containing the capacities.
+ /// The default map type is \ref concepts::Graph::EdgeMap "GR::EdgeMap<int>".
#ifdef DOXYGEN
template <typename GR,
typename CAP>
@@ -70,9 +68,9 @@
class GomoryHu {
public:
- /// The graph type
+ /// The graph type of the algorithm
typedef GR Graph;
- /// The type of the edge capacity map
+ /// The capacity map type of the algorithm
typedef CAP Capacity;
/// The value type of capacities
typedef typename Capacity::Value Value;
@@ -117,7 +115,7 @@
/// \brief Constructor
///
- /// Constructor
+ /// Constructor.
/// \param graph The undirected graph the algorithm runs on.
/// \param capacity The edge capacity map.
GomoryHu(const Graph& graph, const Capacity& capacity)
@@ -130,7 +128,7 @@
/// \brief Destructor
///
- /// Destructor
+ /// Destructor.
~GomoryHu() {
destroyStructures();
}
@@ -215,43 +213,53 @@
///\name Query Functions
///The results of the algorithm can be obtained using these
///functions.\n
- ///\ref run() "run()" should be called before using them.\n
+ ///\ref run() should be called before using them.\n
///See also \ref MinCutNodeIt and \ref MinCutEdgeIt.
///@{
/// \brief Return the predecessor node in the Gomory-Hu tree.
///
- /// This function returns the predecessor node in the Gomory-Hu tree.
- /// If the node is
- /// the root of the Gomory-Hu tree, then it returns \c INVALID.
- Node predNode(const Node& node) {
+ /// This function returns the predecessor node of the given node
+ /// in the Gomory-Hu tree.
+ /// If \c node is the root of the tree, then it returns \c INVALID.
+ ///
+ /// \pre \ref run() must be called before using this function.
+ Node predNode(const Node& node) const {
return (*_pred)[node];
}
- /// \brief Return the distance from the root node in the Gomory-Hu tree.
- ///
- /// This function returns the distance of \c node from the root node
- /// in the Gomory-Hu tree.
- int rootDist(const Node& node) {
- return (*_order)[node];
- }
-
/// \brief Return the weight of the predecessor edge in the
/// Gomory-Hu tree.
///
- /// This function returns the weight of the predecessor edge in the
- /// Gomory-Hu tree. If the node is the root, the result is undefined.
- Value predValue(const Node& node) {
+ /// This function returns the weight of the predecessor edge of the
+ /// given node in the Gomory-Hu tree.
+ /// If \c node is the root of the tree, the result is undefined.
+ ///
+ /// \pre \ref run() must be called before using this function.
+ Value predValue(const Node& node) const {
return (*_weight)[node];
}
+ /// \brief Return the distance from the root node in the Gomory-Hu tree.
+ ///
+ /// This function returns the distance of the given node from the root
+ /// node in the Gomory-Hu tree.
+ ///
+ /// \pre \ref run() must be called before using this function.
+ int rootDist(const Node& node) const {
+ return (*_order)[node];
+ }
+
/// \brief Return the minimum cut value between two nodes
///
- /// This function returns the minimum cut value between two nodes. The
- /// algorithm finds the nearest common ancestor in the Gomory-Hu
- /// tree and calculates the minimum weight edge on the paths to
- /// the ancestor.
+ /// This function returns the minimum cut value between the nodes
+ /// \c s and \c t.
+ /// It finds the nearest common ancestor of the given nodes in the
+ /// Gomory-Hu tree and calculates the minimum weight edge on the
+ /// paths to the ancestor.
+ ///
+ /// \pre \ref run() must be called before using this function.
Value minCutValue(const Node& s, const Node& t) const {
Node sn = s, tn = t;
Value value = std::numeric_limits<Value>::max();
@@ -274,16 +282,23 @@
/// in the \c cutMap parameter by setting the nodes in the component of
/// \c s to \c true and the other nodes to \c false.
///
- /// For higher level interfaces, see MinCutNodeIt and MinCutEdgeIt.
+ /// For higher level interfaces see MinCutNodeIt and MinCutEdgeIt.
+ ///
+ /// \param s The base node.
+ /// \param t The node you want to separate from node \c s.
+ /// \param cutMap The cut will be returned in this map.
+ /// It must be a \c bool (or convertible) \ref concepts::ReadWriteMap
+ /// "ReadWriteMap" on the graph nodes.
+ ///
+ /// \return The value of the minimum cut between \c s and \c t.
+ ///
+ /// \pre \ref run() must be called before using this function.
template <typename CutMap>
- Value minCutMap(const Node& s, ///< The base node.
+ Value minCutMap(const Node& s, ///<
const Node& t,
- ///< The node you want to separate from node \c s.
+ ///<
CutMap& cutMap
- ///< The cut will be returned in this map.
- /// It must be a \c bool (or convertible)
- /// \ref concepts::ReadWriteMap "ReadWriteMap"
- /// on the graph nodes.
+ ///<
) const {
Node sn = s, tn = t;
bool s_root=false;
@@ -338,7 +353,7 @@
/// Iterate on the nodes of a minimum cut
/// This iterator class lists the nodes of a minimum cut found by
- /// GomoryHu. Before using it, you must allocate a GomoryHu class,
+ /// GomoryHu. Before using it, you must allocate a GomoryHu class
/// and call its \ref GomoryHu::run() "run()" method.
///
/// This example counts the nodes in the minimum cut separating \c s from
@@ -435,7 +450,7 @@
/// Iterate on the edges of a minimum cut
/// This iterator class lists the edges of a minimum cut found by
- /// GomoryHu. Before using it, you must allocate a GomoryHu class,
+ /// GomoryHu. Before using it, you must allocate a GomoryHu class
/// and call its \ref GomoryHu::run() "run()" method.
///
/// This example computes the value of the minimum cut separating \c s from
@@ -447,8 +462,8 @@
/// for(GomoruHu<Graph>::MinCutEdgeIt e(gom,s,t); e!=INVALID; ++e)
/// value+=capacities[e];
/// \endcode
- /// the result will be the same as it is returned by
- /// \ref GomoryHu::minCutValue() "gom.minCutValue(s,t)"
+ /// The result will be the same as the value returned by
+ /// \ref GomoryHu::minCutValue() "gom.minCutValue(s,t)".
class MinCutEdgeIt
{
bool _side;
@@ -468,6 +483,10 @@
}
public:
+ /// Constructor
+
+ /// Constructor.
+ ///
MinCutEdgeIt(GomoryHu const &gomory,
///< The GomoryHu class. You must call its
/// run() method
@@ -478,7 +497,7 @@
bool side=true
///< If it is \c true (default) then the listed arcs
/// will be oriented from the
- /// the nodes of the component containing \c s,
+ /// nodes of the component containing \c s,
/// otherwise they will be oriented in the opposite
/// direction.
)
diff --git a/lemon/hao_orlin.h b/lemon/hao_orlin.h
--- a/lemon/hao_orlin.h
+++ b/lemon/hao_orlin.h
@@ -31,39 +31,41 @@
/// \ingroup min_cut
/// \brief Implementation of the Hao-Orlin algorithm.
///
-/// Implementation of the Hao-Orlin algorithm class for testing network
-/// reliability.
+/// Implementation of the Hao-Orlin algorithm for finding a minimum cut
+/// in a digraph.
namespace lemon {
/// \ingroup min_cut
///
- /// \brief %Hao-Orlin algorithm to find a minimum cut in directed graphs.
+ /// \brief Hao-Orlin algorithm for finding a minimum cut in a digraph.
///
- /// Hao-Orlin calculates a minimum cut in a directed graph
- /// \f$D=(V,A)\f$. It takes a fixed node \f$ source \in V \f$ and
+ /// This class implements the Hao-Orlin algorithm for finding a minimum
+ /// 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
- /// out-degree) and in the second phase it determines a minimum cut
+ /// \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
- /// out-degree). Obviously, the smaller of these two cuts will be a
+ /// \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
- /// push-relabel preflow algorithm and our implementation calculates
+ /// preflow push-relabel algorithm. Our implementation calculates
/// the minimum cut in \f$ O(n^2\sqrt{m}) \f$ time (we use the
/// highest-label rule), or in \f$O(nm)\f$ for unit capacities. The
- /// purpose of such algorithm is testing network reliability. 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.
+ /// purpose of such algorithm is e.g. testing network reliability.
///
- /// \param GR The digraph class the algorithm runs on.
- /// \param CAP An arc map of capacities which can be any numreric type.
- /// The default type is \ref concepts::Digraph::ArcMap "GR::ArcMap<int>".
- /// \param TOL Tolerance class for handling inexact computations. 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>".
#ifdef DOXYGEN
template <typename GR, typename CAP, typename TOL>
@@ -73,15 +75,20 @@
typename TOL = Tolerance<typename CAP::Value> >
#endif
class HaoOrlin {
+ public:
+
+ /// The digraph type of the algorithm
+ typedef GR Digraph;
+ /// The capacity map type of the algorithm
+ typedef CAP CapacityMap;
+ /// The tolerance type of the algorithm
+ typedef TOL Tolerance;
+
private:
- typedef GR Digraph;
More information about the Lemon-commits
mailing list