diff -r 30fb4d68b0e8 -r 8f41a3129746 lemon/capacity_scaling.h
--- a/lemon/capacity_scaling.h	Sun Oct 05 13:36:43 2008 +0000
+++ b/lemon/capacity_scaling.h	Sun Oct 05 13:37:17 2008 +0000
@@ -52,7 +52,6 @@
   /// - \c CostMap::Value must be signed type.
   ///
   /// \author Peter Kovacs
-
   template < typename Graph,
              typename LowerMap = typename Graph::template EdgeMap<int>,
              typename CapacityMap = typename Graph::template EdgeMap<int>,
@@ -125,7 +124,7 @@
         _pred(pred)
       {}
 
-      /// Runs the algorithm from the given source node.
+      /// Run the algorithm from the given source node.
       Node run(Node s, Capacity delta = 1) {
         HeapCrossRef heap_cross_ref(_graph, Heap::PRE_HEAP);
         Heap heap(heap_cross_ref);
@@ -371,9 +370,9 @@
       delete _dijkstra;
     }
 
-    /// \brief Sets the flow map.
+    /// \brief Set the flow map.
     ///
-    /// Sets the flow map.
+    /// Set the flow map.
     ///
     /// \return \c (*this)
     CapacityScaling& flowMap(FlowMap &map) {
@@ -385,9 +384,9 @@
       return *this;
     }
 
-    /// \brief Sets the potential map.
+    /// \brief Set the potential map.
     ///
-    /// Sets the potential map.
+    /// Set the potential map.
     ///
     /// \return \c (*this)
     CapacityScaling& potentialMap(PotentialMap &map) {
@@ -400,14 +399,12 @@
     }
 
     /// \name Execution control
-    /// The only way to execute the algorithm is to call the run()
-    /// function.
 
     /// @{
 
-    /// \brief Runs the algorithm.
+    /// \brief Run the algorithm.
     ///
-    /// Runs the algorithm.
+    /// This function runs the algorithm.
     ///
     /// \param scaling Enable or disable capacity scaling.
     /// If the maximum edge capacity and/or the amount of total supply
@@ -422,26 +419,27 @@
     /// @}
 
     /// \name Query Functions
-    /// The result of the algorithm can be obtained using these
-    /// functions.
-    /// \n run() must be called before using them.
+    /// The results of the algorithm can be obtained using these
+    /// functions.\n
+    /// \ref lemon::CapacityScaling::run() "run()" must be called before
+    /// using them.
 
     /// @{
 
-    /// \brief Returns a const reference to the edge map storing the
+    /// \brief Return a const reference to the edge map storing the
     /// found flow.
     ///
-    /// Returns a const reference to the edge map storing the found flow.
+    /// Return a const reference to the edge map storing the found flow.
     ///
     /// \pre \ref run() must be called before using this function.
     const FlowMap& flowMap() const {
       return *_flow;
     }
 
-    /// \brief Returns a const reference to the node map storing the
+    /// \brief Return a const reference to the node map storing the
     /// found potentials (the dual solution).
     ///
-    /// Returns a const reference to the node map storing the found
+    /// Return a const reference to the node map storing the found
     /// potentials (the dual solution).
     ///
     /// \pre \ref run() must be called before using this function.
@@ -449,27 +447,27 @@
       return *_potential;
     }
 
-    /// \brief Returns the flow on the given edge.
+    /// \brief Return the flow on the given edge.
     ///
-    /// Returns the flow on the given edge.
+    /// Return the flow on the given edge.
     ///
     /// \pre \ref run() must be called before using this function.
     Capacity flow(const Edge& edge) const {
       return (*_flow)[edge];
     }
 
-    /// \brief Returns the potential of the given node.
+    /// \brief Return the potential of the given node.
     ///
-    /// Returns the potential of the given node.
+    /// Return the potential of the given node.
     ///
     /// \pre \ref run() must be called before using this function.
     Cost potential(const Node& node) const {
       return (*_potential)[node];
     }
 
-    /// \brief Returns the total cost of the found flow.
+    /// \brief Return the total cost of the found flow.
     ///
-    /// Returns the total cost of the found flow. The complexity of the
+    /// Return the total cost of the found flow. The complexity of the
     /// function is \f$ O(e) \f$.
     ///
     /// \pre \ref run() must be called before using this function.
@@ -484,7 +482,7 @@
 
   private:
 
-    /// Initializes the algorithm.
+    /// Initialize the algorithm.
     bool init(bool scaling) {
       if (!_valid_supply) return false;
 
@@ -535,7 +533,7 @@
         return startWithoutScaling();
     }
 
-    /// Executes the capacity scaling algorithm.
+    /// Execute the capacity scaling algorithm.
     bool startWithScaling() {
       // Processing capacity scaling phases
       Node s, t;
@@ -567,15 +565,16 @@
           if (_excess[n] >=  _delta) _excess_nodes.push_back(n);
           if (_excess[n] <= -_delta) _deficit_nodes.push_back(n);
         }
-        int next_node = 0;
+        int next_node = 0, next_def_node = 0;
 
         // Finding augmenting shortest paths
         while (next_node < int(_excess_nodes.size())) {
           // Checking deficit nodes
           if (_delta > 1) {
             bool delta_deficit = false;
-            for (int i = 0; i < int(_deficit_nodes.size()); ++i) {
-              if (_excess[_deficit_nodes[i]] <= -_delta) {
+            for ( ; next_def_node < int(_deficit_nodes.size());
+                    ++next_def_node ) {
+              if (_excess[_deficit_nodes[next_def_node]] <= -_delta) {
                 delta_deficit = true;
                 break;
               }
@@ -641,7 +640,7 @@
       return true;
     }
 
-    /// Executes the successive shortest path algorithm.
+    /// Execute the successive shortest path algorithm.
     bool startWithoutScaling() {
       // Finding excess nodes
       for (NodeIt n(_graph); n != INVALID; ++n)