source: lemon-0.x/lemon/network_simplex.h @ 2486:0c498f2239a8

/* -*- C++ -*-
 *
 * This file is a part of LEMON, a generic C++ optimization library
 *
 * Copyright (C) 2003-2007
 * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
 * (Egervary Research Group on Combinatorial Optimization, EGRES).
 *
 * Permission to use, modify and distribute this software is granted
 * provided that this copyright notice appears in all copies. For
 * precise terms see the accompanying LICENSE file.
 *
 * This software is provided "AS IS" with no warranty of any kind,
 * express or implied, and with no claim as to its suitability for any
 * purpose.
 *
 */

#ifndef LEMON_NETWORK_SIMPLEX_H
#define LEMON_NETWORK_SIMPLEX_H

/// \ingroup min_cost_flow
///
/// \file
/// \brief The network simplex algorithm for finding a minimum cost
/// flow.

#include <limits>
#include <lemon/smart_graph.h>
#include <lemon/graph_utils.h>

/// \brief The pivot rule used in the algorithm.
//#define FIRST_ELIGIBLE_PIVOT
//#define BEST_ELIGIBLE_PIVOT
#define EDGE_BLOCK_PIVOT
//#define CANDIDATE_LIST_PIVOT
//#define SORTED_LIST_PIVOT

//#define _DEBUG_ITER_


/// \brief State constant for edges at their lower bounds.
#define LOWER   1
/// \brief State constant for edges in the spanning tree.
#define TREE    0
/// \brief State constant for edges at their upper bounds.
#define UPPER   -1

#ifdef EDGE_BLOCK_PIVOT
  #include <cmath>
  /// \brief Lower bound for the size of blocks.
  #define MIN_BLOCK_SIZE        10
#endif

#ifdef CANDIDATE_LIST_PIVOT
  #include <vector>
  #define LIST_LENGTH_DIV           50
  #define MINOR_LIMIT_DIV           200
#endif

#ifdef SORTED_LIST_PIVOT
  #include <vector>
  #include <algorithm>
  #define LIST_LENGTH_DIV       100
  #define LOWER_DIV             4
#endif

namespace lemon {

  /// \addtogroup min_cost_flow
  /// @{

  /// \brief Implementation of the network simplex algorithm for
  /// finding a minimum cost flow.
  ///
  /// \ref lemon::NetworkSimplex "NetworkSimplex" implements the
  /// network simplex algorithm for finding a minimum cost flow.
  ///
  /// \param Graph The directed graph type the algorithm runs on.
  /// \param LowerMap The type of the lower bound map.
  /// \param CapacityMap The type of the capacity (upper bound) map.
  /// \param CostMap The type of the cost (length) map.
  /// \param SupplyMap The type of the supply map.
  ///
  /// \warning
  /// - Edge capacities and costs should be nonnegative integers.
  ///   However \c CostMap::Value should be signed type.
  /// - Supply values should be integers.
  /// - \c LowerMap::Value must be convertible to
  ///   \c CapacityMap::Value and \c CapacityMap::Value must be
  ///   convertible to \c SupplyMap::Value.
  ///
  /// \author Peter Kovacs

template < typename Graph,
           typename LowerMap = typename Graph::template EdgeMap<int>,
           typename CapacityMap = LowerMap,
           typename CostMap = typename Graph::template EdgeMap<int>,
           typename SupplyMap = typename Graph::template NodeMap
                                <typename CapacityMap::Value> >
  class NetworkSimplex
  {
    typedef typename LowerMap::Value Lower;
    typedef typename CapacityMap::Value Capacity;
    typedef typename CostMap::Value Cost;
    typedef typename SupplyMap::Value Supply;

    typedef SmartGraph SGraph;
    typedef typename SGraph::Node Node;
    typedef typename SGraph::NodeIt NodeIt;
    typedef typename SGraph::Edge Edge;
    typedef typename SGraph::EdgeIt EdgeIt;
    typedef typename SGraph::InEdgeIt InEdgeIt;
    typedef typename SGraph::OutEdgeIt OutEdgeIt;

    typedef typename SGraph::template EdgeMap<Lower> SLowerMap;
    typedef typename SGraph::template EdgeMap<Capacity> SCapacityMap;
    typedef typename SGraph::template EdgeMap<Cost> SCostMap;
    typedef typename SGraph::template NodeMap<Supply> SSupplyMap;
    typedef typename SGraph::template NodeMap<Cost> SPotentialMap;

    typedef typename SGraph::template NodeMap<int> IntNodeMap;
    typedef typename SGraph::template NodeMap<bool> BoolNodeMap;
    typedef typename SGraph::template NodeMap<Node> NodeNodeMap;
    typedef typename SGraph::template NodeMap<Edge> EdgeNodeMap;
    typedef typename SGraph::template EdgeMap<int> IntEdgeMap;

    typedef typename Graph::template NodeMap<Node> NodeRefMap;
    typedef typename Graph::template EdgeMap<Edge> EdgeRefMap;

  public:

    /// \brief The type of the flow map.
    typedef typename Graph::template EdgeMap<Capacity> FlowMap;
    /// \brief The type of the potential map.
    typedef typename Graph::template NodeMap<Cost> PotentialMap;

  protected:

    /// \brief Map adaptor class for handling reduced edge costs.
    class ReducedCostMap : public MapBase<Edge, Cost>
    {
    private:

      const SGraph &gr;
      const SCostMap &cost_map;
      const SPotentialMap &pot_map;

    public:

      typedef typename MapBase<Edge, Cost>::Value Value;
      typedef typename MapBase<Edge, Cost>::Key Key;

      ReducedCostMap( const SGraph &_gr,
                      const SCostMap &_cm,
                      const SPotentialMap &_pm ) :
        gr(_gr), cost_map(_cm), pot_map(_pm) {}

      Value operator[](const Key &e) const {
        return cost_map[e] - pot_map[gr.source(e)] + pot_map[gr.target(e)];
      }

    }; //class ReducedCostMap

  protected:

    /// \brief The directed graph the algorithm runs on.
    SGraph graph;
    /// \brief The original graph.
    const Graph &graph_ref;
    /// \brief The original lower bound map.
    const LowerMap *lower;
    /// \brief The capacity map.
    SCapacityMap capacity;
    /// \brief The cost map.
    SCostMap cost;
    /// \brief The supply map.
    SSupplyMap supply;
    /// \brief The reduced cost map.
    ReducedCostMap red_cost;
    /// \brief The sum of supply values equals zero.
    bool valid_supply;

    /// \brief The edge map of the current flow.
    SCapacityMap flow;
    /// \brief The edge map of the found flow on the original graph.
    FlowMap flow_result;
    /// \brief The potential node map.
    SPotentialMap potential;
    /// \brief The potential node map on the original graph.
    PotentialMap potential_result;

    /// \brief Node reference for the original graph.
    NodeRefMap node_ref;
    /// \brief Edge reference for the original graph.
    EdgeRefMap edge_ref;

    /// \brief The depth node map of the spanning tree structure.
    IntNodeMap depth;
    /// \brief The parent node map of the spanning tree structure.
    NodeNodeMap parent;
    /// \brief The pred_edge node map of the spanning tree structure.
    EdgeNodeMap pred_edge;
    /// \brief The thread node map of the spanning tree structure.
    NodeNodeMap thread;
    /// \brief The forward node map of the spanning tree structure.
    BoolNodeMap forward;
    /// \brief The state edge map.
    IntEdgeMap state;


#ifdef EDGE_BLOCK_PIVOT
    /// \brief The size of blocks for the "Edge Block" pivot rule.
    int block_size;
#endif
#ifdef CANDIDATE_LIST_PIVOT
    /// \brief The list of candidate edges for the "Candidate List"
    /// pivot rule.
    std::vector<Edge> candidates;
    /// \brief The maximum length of the edge list for the
    /// "Candidate List" pivot rule.
    int list_length;
    /// \brief The maximum number of minor iterations between two major
    /// itarations.
    int minor_limit;
    /// \brief The number of minor iterations.
    int minor_count;
#endif
#ifdef SORTED_LIST_PIVOT
    /// \brief The list of candidate edges for the "Sorted List"
    /// pivot rule.
    std::vector<Edge> candidates;
    /// \brief The maximum length of the edge list for the
    /// "Sorted List" pivot rule.
    int list_length;
    int list_index;
#endif

    // Root node of the starting spanning tree.
    Node root;
    // The entering edge of the current pivot iteration.
    Edge in_edge;
    // Temporary nodes used in the current pivot iteration.
    Node join, u_in, v_in, u_out, v_out;
    Node right, first, second, last;
    Node stem, par_stem, new_stem;
    // The maximum augment amount along the cycle in the current pivot
    // iteration.
    Capacity delta;

  public :

    /// \brief General constructor of the class (with lower bounds).
    ///
    /// General constructor of the class (with lower bounds).
    ///
    /// \param _graph The directed graph the algorithm runs on.
    /// \param _lower The lower bounds of the edges.
    /// \param _capacity The capacities (upper bounds) of the edges.
    /// \param _cost The cost (length) values of the edges.
    /// \param _supply The supply values of the nodes (signed).
    NetworkSimplex( const Graph &_graph,
                    const LowerMap &_lower,
                    const CapacityMap &_capacity,
                    const CostMap &_cost,
                    const SupplyMap &_supply ) :
      graph_ref(_graph), lower(&_lower), capacity(graph), cost(graph),
      supply(graph), flow(graph), flow_result(_graph), potential(graph),
      potential_result(_graph), depth(graph), parent(graph),
      pred_edge(graph), thread(graph), forward(graph), state(graph),
      node_ref(graph_ref), edge_ref(graph_ref),
      red_cost(graph, cost, potential)
    {
      // Checking the sum of supply values
      Supply sum = 0;
      for (typename Graph::NodeIt n(graph_ref); n != INVALID; ++n)
        sum += _supply[n];
      if (!(valid_supply = sum == 0)) return;

      // Copying graph_ref to graph
      graph.reserveNode(countNodes(graph_ref) + 1);
      graph.reserveEdge(countEdges(graph_ref) + countNodes(graph_ref));
      copyGraph(graph, graph_ref)
        .edgeMap(cost, _cost)
        .nodeRef(node_ref)
        .edgeRef(edge_ref)
        .run();

      // Removing nonzero lower bounds
      for (typename Graph::EdgeIt e(graph_ref); e != INVALID; ++e) {
        capacity[edge_ref[e]] = _capacity[e] - _lower[e];
      }
      for (typename Graph::NodeIt n(graph_ref); n != INVALID; ++n) {
        Supply s = _supply[n];
        for (typename Graph::InEdgeIt e(graph_ref, n); e != INVALID; ++e)
          s += _lower[e];
        for (typename Graph::OutEdgeIt e(graph_ref, n); e != INVALID; ++e)
          s -= _lower[e];
        supply[node_ref[n]] = s;
      }
    }

    /// \brief General constructor of the class (without lower bounds).
    ///
    /// General constructor of the class (without lower bounds).
    ///
    /// \param _graph The directed graph the algorithm runs on.
    /// \param _capacity The capacities (upper bounds) of the edges.
    /// \param _cost The cost (length) values of the edges.
    /// \param _supply The supply values of the nodes (signed).
    NetworkSimplex( const Graph &_graph,
                    const CapacityMap &_capacity,
                    const CostMap &_cost,
                    const SupplyMap &_supply ) :
      graph_ref(_graph), lower(NULL), capacity(graph), cost(graph),
      supply(graph), flow(graph), flow_result(_graph), potential(graph),
      potential_result(_graph), depth(graph), parent(graph),
      pred_edge(graph), thread(graph), forward(graph), state(graph),
      node_ref(graph_ref), edge_ref(graph_ref),
      red_cost(graph, cost, potential)
    {
      // Checking the sum of supply values
      Supply sum = 0;
      for (typename Graph::NodeIt n(graph_ref); n != INVALID; ++n)
        sum += _supply[n];
      if (!(valid_supply = sum == 0)) return;

      // Copying graph_ref to graph
      copyGraph(graph, graph_ref)
        .edgeMap(capacity, _capacity)
        .edgeMap(cost, _cost)
        .nodeMap(supply, _supply)
        .nodeRef(node_ref)
        .edgeRef(edge_ref)
        .run();
    }

    /// \brief Simple constructor of the class (with lower bounds).
    ///
    /// Simple constructor of the class (with lower bounds).
    ///
    /// \param _graph The directed graph the algorithm runs on.
    /// \param _lower The lower bounds of the edges.
    /// \param _capacity The capacities (upper bounds) of the edges.
    /// \param _cost The cost (length) values of the edges.
    /// \param _s The source node.
    /// \param _t The target node.
    /// \param _flow_value The required amount of flow from node \c _s
    /// to node \c _t (i.e. the supply of \c _s and the demand of
    /// \c _t).
    NetworkSimplex( const Graph &_graph,
                    const LowerMap &_lower,
                    const CapacityMap &_capacity,
                    const CostMap &_cost,
                    typename Graph::Node _s,
                    typename Graph::Node _t,
                    typename SupplyMap::Value _flow_value ) :
      graph_ref(_graph), lower(&_lower), capacity(graph), cost(graph),
      supply(graph), flow(graph), flow_result(_graph), potential(graph),
      potential_result(_graph), depth(graph), parent(graph),
      pred_edge(graph), thread(graph), forward(graph), state(graph),
      node_ref(graph_ref), edge_ref(graph_ref),
      red_cost(graph, cost, potential)
    {
      // Copying graph_ref to graph
      copyGraph(graph, graph_ref)
        .edgeMap(cost, _cost)
        .nodeRef(node_ref)
        .edgeRef(edge_ref)
        .run();

      // Removing nonzero lower bounds
      for (typename Graph::EdgeIt e(graph_ref); e != INVALID; ++e) {
        capacity[edge_ref[e]] = _capacity[e] - _lower[e];
      }
      for (typename Graph::NodeIt n(graph_ref); n != INVALID; ++n) {
        Supply s = 0;
        if (n == _s) s =  _flow_value;
        if (n == _t) s = -_flow_value;
        for (typename Graph::InEdgeIt e(graph_ref, n); e != INVALID; ++e)
          s += _lower[e];
        for (typename Graph::OutEdgeIt e(graph_ref, n); e != INVALID; ++e)
          s -= _lower[e];
        supply[node_ref[n]] = s;
      }
      valid_supply = true;
    }

    /// \brief Simple constructor of the class (without lower bounds).
    ///
    /// Simple constructor of the class (without lower bounds).
    ///
    /// \param _graph The directed graph the algorithm runs on.
    /// \param _capacity The capacities (upper bounds) of the edges.
    /// \param _cost The cost (length) values of the edges.
    /// \param _s The source node.
    /// \param _t The target node.
    /// \param _flow_value The required amount of flow from node \c _s
    /// to node \c _t (i.e. the supply of \c _s and the demand of
    /// \c _t).
    NetworkSimplex( const Graph &_graph,
                    const CapacityMap &_capacity,
                    const CostMap &_cost,
                    typename Graph::Node _s,
                    typename Graph::Node _t,
                    typename SupplyMap::Value _flow_value ) :
      graph_ref(_graph), lower(NULL), capacity(graph), cost(graph),
      supply(graph, 0), flow(graph), flow_result(_graph), potential(graph),
      potential_result(_graph), depth(graph), parent(graph),
      pred_edge(graph), thread(graph), forward(graph), state(graph),
      node_ref(graph_ref), edge_ref(graph_ref),
      red_cost(graph, cost, potential)
    {
      // Copying graph_ref to graph
      copyGraph(graph, graph_ref)
        .edgeMap(capacity, _capacity)
        .edgeMap(cost, _cost)
        .nodeRef(node_ref)
        .edgeRef(edge_ref)
        .run();
      supply[node_ref[_s]] =  _flow_value;
      supply[node_ref[_t]] = -_flow_value;
      valid_supply = true;
    }

    /// \brief Returns a const reference to the flow map.
    ///
    /// Returns a const reference to the flow map.
    ///
    /// \pre \ref run() must be called before using this function.
    const FlowMap& flowMap() const {
      return flow_result;
    }

    /// \brief Returns a const reference to the potential map (the dual
    /// solution).
    ///
    /// Returns a const reference to the potential map (the dual
    /// solution).
    ///
    /// \pre \ref run() must be called before using this function.
    const PotentialMap& potentialMap() const {
      return potential_result;
    }

    /// \brief Returns the total cost of the found flow.
    ///
    /// Returns 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.
    Cost totalCost() const {
      Cost c = 0;
      for (typename Graph::EdgeIt e(graph_ref); e != INVALID; ++e)
        c += flow_result[e] * cost[edge_ref[e]];
      return c;
    }

    /// \brief Runs the algorithm.
    ///
    /// Runs the algorithm.
    ///
    /// \return \c true if a feasible flow can be found.
    bool run() {
      return init() && start();
    }

  protected:

    /// \brief Extends the underlaying graph and initializes all the
    /// node and edge maps.
    bool init() {
      if (!valid_supply) return false;

      // Initializing state and flow maps
      for (EdgeIt e(graph); e != INVALID; ++e) {
        flow[e] = 0;
        state[e] = LOWER;
      }

      // Adding an artificial root node to the graph
      root = graph.addNode();
      parent[root] = INVALID;
      pred_edge[root] = INVALID;
      depth[root] = 0;
      supply[root] = 0;
      potential[root] = 0;

      // Adding artificial edges to the graph and initializing the node
      // maps of the spanning tree data structure
      Supply sum = 0;
      Node last = root;
      Edge e;
      Cost max_cost = std::numeric_limits<Cost>::max() / 4;
      for (NodeIt u(graph); u != INVALID; ++u) {
        if (u == root) continue;
        thread[last] = u;
        last = u;
        parent[u] = root;
        depth[u] = 1;
        sum += supply[u];
        if (supply[u] >= 0) {
          e = graph.addEdge(u, root);
          flow[e] = supply[u];
          forward[u] = true;
          potential[u] = max_cost;
        } else {
          e = graph.addEdge(root, u);
          flow[e] = -supply[u];
          forward[u] = false;
          potential[u] = -max_cost;
        }
        cost[e] = max_cost;
        capacity[e] = std::numeric_limits<Capacity>::max();
        state[e] = TREE;
        pred_edge[u] = e;
      }
      thread[last] = root;

#ifdef EDGE_BLOCK_PIVOT
      // Initializing block_size for the edge block pivot rule
      int edge_num = countEdges(graph);
      block_size = 2 * int(sqrt(countEdges(graph)));
      if (block_size < MIN_BLOCK_SIZE) block_size = MIN_BLOCK_SIZE;
//      block_size = edge_num >= BLOCK_NUM * MIN_BLOCK_SIZE ?
//                   edge_num / BLOCK_NUM : MIN_BLOCK_SIZE;
#endif
#ifdef CANDIDATE_LIST_PIVOT
      int edge_num = countEdges(graph);
      minor_count = 0;
      list_length = edge_num / LIST_LENGTH_DIV;
      minor_limit = edge_num / MINOR_LIMIT_DIV;
#endif
#ifdef SORTED_LIST_PIVOT
      int edge_num = countEdges(graph);
      list_index = 0;
      list_length = edge_num / LIST_LENGTH_DIV;
#endif

      return sum == 0;
    }

#ifdef FIRST_ELIGIBLE_PIVOT
    /// \brief Finds entering edge according to the "First Eligible"
    /// pivot rule.
    bool findEnteringEdge(EdgeIt &next_edge) {
      for (EdgeIt e = next_edge; e != INVALID; ++e) {
        if (state[e] * red_cost[e] < 0) {
          in_edge = e;
          next_edge = ++e;
          return true;
        }
      }
      for (EdgeIt e(graph); e != next_edge; ++e) {
        if (state[e] * red_cost[e] < 0) {
          in_edge = e;
          next_edge = ++e;
          return true;
        }
      }
      return false;
    }
#endif

#ifdef BEST_ELIGIBLE_PIVOT
    /// \brief Finds entering edge according to the "Best Eligible"
    /// pivot rule.
    bool findEnteringEdge() {
      Cost min = 0;
      for (EdgeIt e(graph); e != INVALID; ++e) {
        if (state[e] * red_cost[e] < min) {
          min = state[e] * red_cost[e];
          in_edge = e;
        }
      }
      return min < 0;
    }
#endif

#ifdef EDGE_BLOCK_PIVOT
    /// \brief Finds entering edge according to the "Edge Block"
    /// pivot rule.
    bool findEnteringEdge(EdgeIt &next_edge) {
      // Performing edge block selection
      Cost curr, min = 0;
      EdgeIt min_edge(graph);
      int cnt = 0;
      for (EdgeIt e = next_edge; e != INVALID; ++e) {
        if ((curr = state[e] * red_cost[e]) < min) {
          min = curr;
          min_edge = e;
        }
        if (++cnt == block_size) {
          if (min < 0) break;
          cnt = 0;
        }
      }
      if (!(min < 0)) {
        for (EdgeIt e(graph); e != next_edge; ++e) {
          if ((curr = state[e] * red_cost[e]) < min) {
            min = curr;
            min_edge = e;
          }
          if (++cnt == block_size) {
            if (min < 0) break;
            cnt = 0;
          }
        }
      }
      in_edge = min_edge;
      if ((next_edge = ++min_edge) == INVALID)
        next_edge = EdgeIt(graph);
      return min < 0;
    }
#endif

#ifdef CANDIDATE_LIST_PIVOT
    /// \brief Finds entering edge according to the "Candidate List"
    /// pivot rule.
    bool findEnteringEdge() {
      typedef typename std::vector<Edge>::iterator ListIt;

      if (minor_count >= minor_limit || candidates.size() == 0) {
        // Major iteration
        candidates.clear();
        for (EdgeIt e(graph); e != INVALID; ++e) {
          if (state[e] * red_cost[e] < 0) {
            candidates.push_back(e);
            if (candidates.size() == list_length) break;
          }
        }
        if (candidates.size() == 0) return false;
      }

      // Minor iteration
      ++minor_count;
      Cost min = 0;
      Edge e;
      for (int i = 0; i < candidates.size(); ++i) {
        e = candidates[i];
        if (state[e] * red_cost[e] < min) {
          min = state[e] * red_cost[e];
          in_edge = e;
        }
      }
      return true;
    }
#endif

#ifdef SORTED_LIST_PIVOT
    /// \brief Functor class to compare edges during sort of the
    /// candidate list.
    class SortFunc
    {
    private:
      const IntEdgeMap &st;
      const ReducedCostMap &rc;
    public:
      SortFunc(const IntEdgeMap &_st, const ReducedCostMap &_rc) :
        st(_st), rc(_rc) {}
      bool operator()(const Edge &e1, const Edge &e2) {
        return st[e1] * rc[e1] < st[e2] * rc[e2];
      }
    };

    /// \brief Finds entering edge according to the "Sorted List"
    /// pivot rule.
    bool findEnteringEdge() {
      static SortFunc sort_func(state, red_cost);

      // Minor iteration
      while (list_index < candidates.size()) {
        in_edge = candidates[list_index++];
        if (state[in_edge] * red_cost[in_edge] < 0) return true;
      }

      // Major iteration
      candidates.clear();
      Cost curr, min = 0;
      for (EdgeIt e(graph); e != INVALID; ++e) {
        if ((curr = state[e] * red_cost[e]) < min / LOWER_DIV) {
          candidates.push_back(e);
          if (curr < min) min = curr;
          if (candidates.size() == list_length) break;
        }
      }
      if (candidates.size() == 0) return false;
      sort(candidates.begin(), candidates.end(), sort_func);
      in_edge = candidates[0];
      list_index = 1;
      return true;
    }
#endif

    /// \brief Finds the join node.
    Node findJoinNode() {
      // Finding the join node
      Node u = graph.source(in_edge);
      Node v = graph.target(in_edge);
      while (u != v) {
        if (depth[u] == depth[v]) {
          u = parent[u];
          v = parent[v];
        }
        else if (depth[u] > depth[v]) u = parent[u];
        else v = parent[v];
      }
      return u;
    }

    /// \brief Finds the leaving edge of the cycle. Returns \c true if
    /// the leaving edge is not the same as the entering edge.
    bool findLeavingEdge() {
      // Initializing first and second nodes according to the direction
      // of the cycle
      if (state[in_edge] == LOWER) {
        first = graph.source(in_edge);
        second  = graph.target(in_edge);
      } else {
        first = graph.target(in_edge);
        second  = graph.source(in_edge);
      }
      delta = capacity[in_edge];
      bool result = false;
      Capacity d;
      Edge e;

      // Searching the cycle along the path form the first node to the
      // root node
      for (Node u = first; u != join; u = parent[u]) {
        e = pred_edge[u];
        d = forward[u] ? flow[e] : capacity[e] - flow[e];
        if (d < delta) {
          delta = d;
          u_out = u;
          u_in = first;
          v_in = second;
          result = true;
        }
      }
      // Searching the cycle along the path form the second node to the
      // root node
      for (Node u = second; u != join; u = parent[u]) {
        e = pred_edge[u];
        d = forward[u] ? capacity[e] - flow[e] : flow[e];
        if (d <= delta) {
          delta = d;
          u_out = u;
          u_in = second;
          v_in = first;
          result = true;
        }
      }
      return result;
    }

    /// \brief Changes flow and state edge maps.
    void changeFlows(bool change) {
      // Augmenting along the cycle
      if (delta > 0) {
        Capacity val = state[in_edge] * delta;
        flow[in_edge] += val;
        for (Node u = graph.source(in_edge); u != join; u = parent[u]) {
          flow[pred_edge[u]] += forward[u] ? -val : val;
        }
        for (Node u = graph.target(in_edge); u != join; u = parent[u]) {
          flow[pred_edge[u]] += forward[u] ? val : -val;
        }
      }
      // Updating the state of the entering and leaving edges
      if (change) {
        state[in_edge] = TREE;
        state[pred_edge[u_out]] =
          (flow[pred_edge[u_out]] == 0) ? LOWER : UPPER;
      } else {
        state[in_edge] = -state[in_edge];
      }
    }

    /// \brief Updates thread and parent node maps.
    void updateThreadParent() {
      Node u;
      v_out = parent[u_out];

      // Handling the case when join and v_out coincide
      bool par_first = false;
      if (join == v_out) {
        for (u = join; u != u_in && u != v_in; u = thread[u]) ;
        if (u == v_in) {
          par_first = true;
          while (thread[u] != u_out) u = thread[u];
          first = u;
        }
      }

      // Finding the last successor of u_in (u) and the node after it
      // (right) according to the thread index
      for (u = u_in; depth[thread[u]] > depth[u_in]; u = thread[u]) ;
      right = thread[u];
      if (thread[v_in] == u_out) {
        for (last = u; depth[last] > depth[u_out]; last = thread[last]) ;
        if (last == u_out) last = thread[last];
      }
      else last = thread[v_in];

      // Updating stem nodes
      thread[v_in] = stem = u_in;
      par_stem = v_in;
      while (stem != u_out) {
        thread[u] = new_stem = parent[stem];

        // Finding the node just before the stem node (u) according to
        // the original thread index
        for (u = new_stem; thread[u] != stem; u = thread[u]) ;
        thread[u] = right;

        // Changing the parent node of stem and shifting stem and
        // par_stem nodes
        parent[stem] = par_stem;
        par_stem = stem;
        stem = new_stem;

        // Finding the last successor of stem (u) and the node after it
        // (right) according to the thread index
        for (u = stem; depth[thread[u]] > depth[stem]; u = thread[u]) ;
        right = thread[u];
      }
      parent[u_out] = par_stem;
      thread[u] = last;

      if (join == v_out && par_first) {
        if (first != v_in) thread[first] = right;
      } else {
        for (u = v_out; thread[u] != u_out; u = thread[u]) ;
        thread[u] = right;
      }
    }

    /// \brief Updates pred_edge and forward node maps.
    void updatePredEdge() {
      Node u = u_out, v;
      while (u != u_in) {
        v = parent[u];
        pred_edge[u] = pred_edge[v];
        forward[u] = !forward[v];
        u = v;
      }
      pred_edge[u_in] = in_edge;
      forward[u_in] = (u_in == graph.source(in_edge));
    }

    /// \brief Updates depth and potential node maps.
    void updateDepthPotential() {
      depth[u_in] = depth[v_in] + 1;
      potential[u_in] = forward[u_in] ?
        potential[v_in] + cost[pred_edge[u_in]] :
        potential[v_in] - cost[pred_edge[u_in]];

      Node u = thread[u_in], v;
      while (true) {
        v = parent[u];
        if (v == INVALID) break;
        depth[u] = depth[v] + 1;
        potential[u] = forward[u] ?
          potential[v] + cost[pred_edge[u]] :
          potential[v] - cost[pred_edge[u]];
        if (depth[u] <= depth[v_in]) break;
        u = thread[u];
      }
    }

    /// \brief Executes the algorithm.
    bool start() {
      // Processing pivots
#ifdef _DEBUG_ITER_
      int iter_num = 0;
#endif
#if defined(FIRST_ELIGIBLE_PIVOT) || defined(EDGE_BLOCK_PIVOT)
      EdgeIt next_edge(graph);
      while (findEnteringEdge(next_edge))
#else
      while (findEnteringEdge())
#endif
      {
        join = findJoinNode();
        bool change = findLeavingEdge();
        changeFlows(change);
        if (change) {
          updateThreadParent();
          updatePredEdge();
          updateDepthPotential();
        }
#ifdef _DEBUG_ITER_
        ++iter_num;
#endif
      }

#ifdef _DEBUG_ITER_
      std::cout << "Network Simplex algorithm finished. " << iter_num
                << " pivot iterations performed." << std::endl;
#endif

      // Checking if the flow amount equals zero on all the
      // artificial edges
      for (InEdgeIt e(graph, root); e != INVALID; ++e)
        if (flow[e] > 0) return false;
      for (OutEdgeIt e(graph, root); e != INVALID; ++e)
        if (flow[e] > 0) return false;

      // Copying flow values to flow_result
      if (lower) {
        for (typename Graph::EdgeIt e(graph_ref); e != INVALID; ++e)
          flow_result[e] = (*lower)[e] + flow[edge_ref[e]];
      } else {
        for (typename Graph::EdgeIt e(graph_ref); e != INVALID; ++e)
          flow_result[e] = flow[edge_ref[e]];
      }
      // Copying potential values to potential_result
      for (typename Graph::NodeIt n(graph_ref); n != INVALID; ++n)
        potential_result[n] = potential[node_ref[n]];

      return true;
    }

  }; //class NetworkSimplex

  ///@}

} //namespace lemon

#endif //LEMON_NETWORK_SIMPLEX_H