[Lemon-commits] [lemon_svn] deba: r2965 - hugo/trunk/lemon

[Lemon SVN]

Author: deba
Date: Fri Sep 29 13:36:30 2006
New Revision: 2965

Modified:
   hugo/trunk/lemon/hao_orlin.h
   hugo/trunk/lemon/min_cut.h

Log:
Doc fix



Modified: hugo/trunk/lemon/hao_orlin.h
==============================================================================
--- hugo/trunk/lemon/hao_orlin.h	(original)
+++ hugo/trunk/lemon/hao_orlin.h	Fri Sep 29 13:36:30 2006
@@ -51,7 +51,7 @@
   /// algorithm and it calculates the minimum cut in \f$ O(n^3) \f$
   /// time. The purpose of such algorithm is testing network
   /// reliability. For sparse undirected graph you can use the
-  /// algorithm of Nagamochi and Ibraki which solves the undirected
+  /// algorithm of Nagamochi and Ibaraki which solves the undirected
   /// problem in \f$ O(ne + n^2 \log(n)) \f$ time and it is implemented in the
   /// MinCut algorithm class.
   ///

Modified: hugo/trunk/lemon/min_cut.h
==============================================================================
--- hugo/trunk/lemon/min_cut.h	(original)
+++ hugo/trunk/lemon/min_cut.h	Fri Sep 29 13:36:30 2006
@@ -830,18 +830,19 @@
 
   /// \ingroup topology
   ///
-  /// \brief Calculates the min cut in an undirected graph.
+  /// \brief Calculates the minimum cut in an undirected graph.
   ///
-  /// Calculates the min cut in an undirected graph. 
-  /// The algorithm separates the graph's nodes into two partitions with the 
-  /// min sum of edge capacities between the two partitions. The
-  /// algorithm can be used to test the network reliability specifically
-  /// to test how many links have to be destroyed in the network to split it 
-  /// at least two distinict subnetwork.
+  /// Calculates the minimum cut in an undirected graph with the
+  /// Nagamochi-Ibaraki algorithm. The algorithm separates the graph's
+  /// nodes into two partitions with the minimum sum of edge capacities
+  /// between the two partitions. The algorithm can be used to test
+  /// the network reliability specifically to test how many links have
+  /// to be destroyed in the network to split it at least two
+  /// distinict subnetwork.
   ///
   /// The complexity of the algorithm is \f$ O(ne\log(n)) \f$ but with
-  /// Fibonacci heap it can be decreased to \f$ O(ne+n^2\log(n)) \f$. When
-  /// the neutral capacity map is used then it uses BucketHeap which
+  /// Fibonacci heap it can be decreased to \f$ O(ne+n^2\log(n))
+  /// \f$. When capacity map is neutral then it uses BucketHeap which
   /// results \f$ O(ne) \f$ time complexity.
 #ifdef DOXYGEN
   template <typename _Graph, typename _CapacityMap, typename _Traits>