Index: doc/groups.dox
===================================================================
--- doc/groups.dox	(revision 1206)
+++ doc/groups.dox	(revision 1217)
@@ -393,5 +393,5 @@
 This group contains the algorithms for finding minimum cost flows and
 circulations \ref amo93networkflows. For more information about this
-problem and its dual solution, see \ref min_cost_flow
+problem and its dual solution, see: \ref min_cost_flow
 "Minimum Cost Flow Problem".
 
@@ -485,6 +485,5 @@
 time is exponential.
 Both \ref KarpMmc "Karp" and \ref HartmannOrlinMmc "Hartmann-Orlin" algorithms
-run in time O(ne) and use space O(n<sup>2</sup>+e), but the latter one is
-typically faster due to the applied early termination scheme.
+run in time O(ne) and use space O(n<sup>2</sup>+e).
 */
 
Index: lemon/capacity_scaling.h
===================================================================
--- lemon/capacity_scaling.h	(revision 1166)
+++ lemon/capacity_scaling.h	(revision 1217)
@@ -69,5 +69,7 @@
   /// \ref min_cost_flow "minimum cost flow" \ref amo93networkflows,
   /// \ref edmondskarp72theoretical. It is an efficient dual
-  /// solution method.
+  /// solution method, which runs in polynomial time
+  /// \f$O(e\log U (n+e)\log n)\f$, where <i>U</i> denotes the maximum
+  /// of node supply and arc capacity values.
   ///
   /// This algorithm is typically slower than \ref CostScaling and
Index: lemon/concepts/bpgraph.h
===================================================================
--- lemon/concepts/bpgraph.h	(revision 1196)
+++ lemon/concepts/bpgraph.h	(revision 1217)
@@ -998,5 +998,5 @@
       /// \brief The base node of the iterator.
       ///
-      /// Returns the base node of the given incomming arc iterator
+      /// Returns the base node of the given incoming arc iterator
       /// (i.e. the target node of the corresponding arc).
       Node baseNode(InArcIt) const { return INVALID; }
@@ -1004,5 +1004,5 @@
       /// \brief The running node of the iterator.
       ///
-      /// Returns the running node of the given incomming arc iterator
+      /// Returns the running node of the given incoming arc iterator
       /// (i.e. the source node of the corresponding arc).
       Node runningNode(InArcIt) const { return INVALID; }
Index: lemon/concepts/digraph.h
===================================================================
--- lemon/concepts/digraph.h	(revision 956)
+++ lemon/concepts/digraph.h	(revision 1217)
@@ -410,5 +410,5 @@
       /// \brief The base node of the iterator.
       ///
-      /// Returns the base node of the given incomming arc iterator
+      /// Returns the base node of the given incoming arc iterator
       /// (i.e. the target node of the corresponding arc).
       Node baseNode(InArcIt) const { return INVALID; }
@@ -416,5 +416,5 @@
       /// \brief The running node of the iterator.
       ///
-      /// Returns the running node of the given incomming arc iterator
+      /// Returns the running node of the given incoming arc iterator
       /// (i.e. the source node of the corresponding arc).
       Node runningNode(InArcIt) const { return INVALID; }
Index: lemon/concepts/graph.h
===================================================================
--- lemon/concepts/graph.h	(revision 1186)
+++ lemon/concepts/graph.h	(revision 1217)
@@ -758,5 +758,5 @@
       /// \brief The base node of the iterator.
       ///
-      /// Returns the base node of the given incomming arc iterator
+      /// Returns the base node of the given incoming arc iterator
       /// (i.e. the target node of the corresponding arc).
       Node baseNode(InArcIt) const { return INVALID; }
@@ -764,5 +764,5 @@
       /// \brief The running node of the iterator.
       ///
-      /// Returns the running node of the given incomming arc iterator
+      /// Returns the running node of the given incoming arc iterator
       /// (i.e. the source node of the corresponding arc).
       Node runningNode(InArcIt) const { return INVALID; }
Index: lemon/concepts/graph_components.h
===================================================================
--- lemon/concepts/graph_components.h	(revision 1196)
+++ lemon/concepts/graph_components.h	(revision 1217)
@@ -876,13 +876,13 @@
       void next(Arc&) const {}
 
-      /// \brief Return the first arc incomming to the given node.
-      ///
-      /// This function gives back the first arc incomming to the
+      /// \brief Return the first arc incoming to the given node.
+      ///
+      /// This function gives back the first arc incoming to the
       /// given node.
       void firstIn(Arc&, const Node&) const {}
 
-      /// \brief Return the next arc incomming to the given node.
-      ///
-      /// This function gives back the next arc incomming to the
+      /// \brief Return the next arc incoming to the given node.
+      ///
+      /// This function gives back the next arc incoming to the
       /// given node.
       void nextIn(Arc&) const {}
Index: lemon/cost_scaling.h
===================================================================
--- lemon/cost_scaling.h	(revision 1165)
+++ lemon/cost_scaling.h	(revision 1217)
@@ -97,4 +97,6 @@
   /// can be viewed as the generalization of the \ref Preflow
   /// "preflow push-relabel" algorithm for the maximum flow problem.
+  /// It is a polynomial algorithm, its running time complexity is
+  /// \f$O(n^2e\log(nK))\f$, where <i>K</i> denotes the maximum arc cost.
   ///
   /// In general, \ref NetworkSimplex and \ref CostScaling are the fastest
@@ -1270,5 +1272,5 @@
           _buckets[r] = _bucket_next[u];
 
-          // Search the incomming arcs of u
+          // Search the incoming arcs of u
           LargeCost pi_u = _pi[u];
           int last_out = _first_out[u+1];
Index: lemon/cycle_canceling.h
===================================================================
--- lemon/cycle_canceling.h	(revision 1179)
+++ lemon/cycle_canceling.h	(revision 1217)
@@ -52,7 +52,7 @@
   /// The most efficent one is the \ref CANCEL_AND_TIGHTEN
   /// "Cancel-and-Tighten" algorithm, thus it is the default method.
-  /// It runs in strongly polynomial time, but in practice, it is typically
-  /// orders of magnitude slower than the scaling algorithms and
-  /// \ref NetworkSimplex.
+  /// It runs in strongly polynomial time O(n<sup>2</sup>e<sup>2</sup>log(n)),
+  /// but in practice, it is typically orders of magnitude slower than
+  /// the scaling algorithms and \ref NetworkSimplex.
   /// (For more information, see \ref min_cost_flow_algs "the module page".)
   ///
Index: lemon/hartmann_orlin_mmc.h
===================================================================
--- lemon/hartmann_orlin_mmc.h	(revision 1164)
+++ lemon/hartmann_orlin_mmc.h	(revision 1217)
@@ -100,7 +100,8 @@
   /// a directed cycle of minimum mean cost in a digraph
   /// \ref hartmann93finding, \ref dasdan98minmeancycle.
-  /// It is an improved version of \ref KarpMmc "Karp"'s original algorithm,
-  /// it applies an efficient early termination scheme.
-  /// It runs in time O(ne) and uses space O(n<sup>2</sup>+e).
+  /// This method is based on \ref KarpMmc "Karp"'s original algorithm, but
+  /// applies an early termination scheme. It makes the algorithm
+  /// significantly faster for some problem instances, but slower for others.
+  /// The algorithm runs in time O(ne) and uses space O(n<sup>2</sup>+e).
   ///
   /// \tparam GR The type of the digraph the algorithm runs on.
@@ -275,6 +276,6 @@
     ///
     /// If you don't call this function before calling \ref run() or
-    /// \ref findCycleMean(), it will allocate a local \ref Path "path"
-    /// structure. The destuctor deallocates this automatically
+    /// \ref findCycleMean(), a local \ref Path "path" structure
+    /// will be allocated. The destuctor deallocates this automatically
     /// allocated object, of course.
     ///
Index: lemon/howard_mmc.h
===================================================================
--- lemon/howard_mmc.h	(revision 1178)
+++ lemon/howard_mmc.h	(revision 1217)
@@ -283,6 +283,6 @@
     ///
     /// If you don't call this function before calling \ref run() or
-    /// \ref findCycleMean(), it will allocate a local \ref Path "path"
-    /// structure. The destuctor deallocates this automatically
+    /// \ref findCycleMean(), a local \ref Path "path" structure
+    /// will be allocated. The destuctor deallocates this automatically
     /// allocated object, of course.
     ///
Index: lemon/karp_mmc.h
===================================================================
--- lemon/karp_mmc.h	(revision 1164)
+++ lemon/karp_mmc.h	(revision 1217)
@@ -271,6 +271,6 @@
     ///
     /// If you don't call this function before calling \ref run() or
-    /// \ref findCycleMean(), it will allocate a local \ref Path "path"
-    /// structure. The destuctor deallocates this automatically
+    /// \ref findCycleMean(), a local \ref Path "path" structure
+    /// will be allocated. The destuctor deallocates this automatically
     /// allocated object, of course.
     ///
Index: lemon/list_graph.h
===================================================================
--- lemon/list_graph.h	(revision 1193)
+++ lemon/list_graph.h	(revision 1217)
@@ -446,5 +446,5 @@
     ///or changeTarget(), thus \c ArcIt and \c OutArcIt iterators are
     ///invalidated for the outgoing arcs of node \c v and \c InArcIt
-    ///iterators are invalidated for the incomming arcs of \c v.
+    ///iterators are invalidated for the incoming arcs of \c v.
     ///Moreover all iterators referencing node \c v or the removed
     ///loops are also invalidated. Other iterators remain valid.
Index: lemon/network_simplex.h
===================================================================
--- lemon/network_simplex.h	(revision 1166)
+++ lemon/network_simplex.h	(revision 1217)
@@ -1504,5 +1504,5 @@
           }
         } else {
-          // Find the min. cost incomming arc for each demand node
+          // Find the min. cost incoming arc for each demand node
           for (int i = 0; i != int(demand_nodes.size()); ++i) {
             Node v = demand_nodes[i];
