RhodeCode

 * 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 Network Simplex algorithm for finding a minimum cost flow.

#include <vector>

#include <limits>

#include <algorithm>

#include <lemon/core.h>

#include <lemon/math.h>

namespace lemon {

  /// \addtogroup min_cost_flow

  /// @{

  /// \brief Implementation of the primal Network Simplex algorithm

  /// for finding a \ref min_cost_flow "minimum cost flow".

  ///

  /// \ref NetworkSimplex implements the primal Network Simplex algorithm

  /// for finding a \ref min_cost_flow "minimum cost flow".

  /// This algorithm is a specialized version of the linear programming

  /// simplex method directly for the minimum cost flow problem.

  /// It is one of the most efficient solution methods.

  ///

  /// In general this class is the fastest implementation available

  /// in LEMON for the minimum cost flow problem.

  ///

  /// \tparam GR The digraph type the algorithm runs on.

  /// \tparam F The value type used for flow amounts, capacity bounds

  /// and supply values in the algorithm. By default it is \c int.

  /// \tparam C The value type used for costs and potentials in the

  /// algorithm. By default it is the same as \c F.

  ///

  ///

  /// \note %NetworkSimplex provides five different pivot rule

  /// implementations. For more information see \ref PivotRule.

  template <typename GR, typename F = int, typename C = F>

  class NetworkSimplex

  {

  public:

    /// The flow type of the algorithm

    typedef F Flow;

    /// The cost type of the algorithm

    typedef C Cost;

    /// The type of the flow map

    typedef typename GR::template ArcMap<Flow> FlowMap;

    /// The type of the potential map

    typedef typename GR::template NodeMap<Cost> PotentialMap;

  public:

    /// \brief Enum type for selecting the pivot rule.

    ///

    /// Enum type for selecting the pivot rule for the \ref run()

    /// function.

    ///

    /// \ref NetworkSimplex provides five different pivot rule

    /// implementations that significantly affect the running time

    /// of the algorithm.

    /// By default \ref BLOCK_SEARCH "Block Search" is used, which

    /// proved to be the most efficient and the most robust on various

    /// test inputs according to our benchmark tests.

    /// However another pivot rule can be selected using the \ref run()

    /// function with the proper parameter.

    enum PivotRule {

      /// The First Eligible pivot rule.

      /// The next eligible arc is selected in a wraparound fashion

      /// in every iteration.

      FIRST_ELIGIBLE,

      /// The Best Eligible pivot rule.

      /// The best eligible arc is selected in every iteration.

      BEST_ELIGIBLE,

      /// The Block Search pivot rule.

      /// A specified number of arcs are examined in every iteration

      /// in a wraparound fashion and the best eligible arc is selected

      /// from this block.

      BLOCK_SEARCH,

      // Initialize node related data

      bool valid_supply = true;

      if (!_pstsup && !_psupply) {

        _pstsup = true;

        _psource = _ptarget = NodeIt(_graph);

        _pstflow = 0;

      }

      if (_psupply) {

        Flow sum = 0;

        int i = 0;

        for (NodeIt n(_graph); n != INVALID; ++n, ++i) {

          _node_id[n] = i;

          _supply[i] = (*_psupply)[n];

          sum += _supply[i];

        }

        valid_supply = (sum == 0);

      } else {

        int i = 0;

        for (NodeIt n(_graph); n != INVALID; ++n, ++i) {

          _node_id[n] = i;

          _supply[i] = 0;

        }

        _supply[_node_id[_psource]] =  _pstflow;

        _supply[_node_id[_ptarget]]   = -_pstflow;

      }

      if (!valid_supply) return false;

      // Set data for the artificial root node

      _root = _node_num;

      _parent[_root] = -1;

      _pred[_root] = -1;

      _thread[_root] = 0;

      _rev_thread[0] = _root;

      _succ_num[_root] = all_node_num;

      _last_succ[_root] = _root - 1;

      _supply[_root] = 0;

      _pi[_root] = 0;

      // Store the arcs in a mixed order

      int k = std::max(int(sqrt(_arc_num)), 10);

      int i = 0;

      for (ArcIt e(_graph); e != INVALID; ++e) {

        _arc_ref[i] = e;

        if ((i += k) >= _arc_num) i = (i % k) + 1;

      }

      // Initialize arc maps

      if (_pupper && _pcost) {

        for (int i = 0; i != _arc_num; ++i) {

          Arc e = _arc_ref[i];

          _source[i] = _node_id[_graph.source(e)];

          _target[i] = _node_id[_graph.target(e)];

          _cap[i] = (*_pupper)[e];

          _cost[i] = (*_pcost)[e];

          _flow[i] = 0;

          _state[i] = STATE_LOWER;

        }

      } else {

        for (int i = 0; i != _arc_num; ++i) {

          Arc e = _arc_ref[i];

          _source[i] = _node_id[_graph.source(e)];

          _target[i] = _node_id[_graph.target(e)];

          _flow[i] = 0;

          _state[i] = STATE_LOWER;

        }

        if (_pupper) {

          for (int i = 0; i != _arc_num; ++i)

            _cap[i] = (*_pupper)[_arc_ref[i]];

        } else {

          for (int i = 0; i != _arc_num; ++i)

        }

        if (_pcost) {

          for (int i = 0; i != _arc_num; ++i)

            _cost[i] = (*_pcost)[_arc_ref[i]];

        } else {

          for (int i = 0; i != _arc_num; ++i)

            _cost[i] = 1;

        }

      }

      // Remove non-zero lower bounds

      if (_plower) {

        for (int i = 0; i != _arc_num; ++i) {

          Flow c = (*_plower)[_arc_ref[i]];

          if (c != 0) {

            _cap[i] -= c;

            _supply[_source[i]] -= c;

            _supply[_target[i]] += c;

          }

        }

      }

      // Add artificial arcs and initialize the spanning tree data structure

      for (int u = 0, e = _arc_num; u != _node_num; ++u, ++e) {

        _thread[u] = u + 1;

        _rev_thread[u + 1] = u;

        _succ_num[u] = 1;

        _last_succ[u] = u;

        _parent[u] = _root;

        _pred[u] = e;

        _state[e] = STATE_TREE;

        if (_supply[u] >= 0) {

          _flow[e] = _supply[u];

          _forward[u] = true;

        } else {

          _flow[e] = -_supply[u];

          _forward[u] = false;

        }

      }

      return true;

    }

    // Find the join node

    void findJoinNode() {

      int u = _source[in_arc];

      int v = _target[in_arc];

      while (u != v) {

        if (_succ_num[u] < _succ_num[v]) {

          u = _parent[u];

        } else {

          v = _parent[v];

        }

      }

      join = u;

    }

    // Find the leaving arc of the cycle and returns true if the

    // leaving arc is not the same as the entering arc

    bool findLeavingArc() {

      // Initialize first and second nodes according to the direction

      // of the cycle

      if (_state[in_arc] == STATE_LOWER) {

        first  = _source[in_arc];

        second = _target[in_arc];

      } else {

        first  = _target[in_arc];

        second = _source[in_arc];

      }

      delta = _cap[in_arc];

      int result = 0;

      Flow d;

      int e;

      // Search the cycle along the path form the first node to the root

      for (int u = first; u != join; u = _parent[u]) {

        e = _pred[u];

        d = _forward[u] ? _flow[e] : _cap[e] - _flow[e];

        if (d < delta) {

          delta = d;

          u_out = u;

          result = 1;

        }

      }

      // Search the cycle along the path form the second node to the root

      }

      _pred[u_in] = in_arc;

      _forward[u_in] = (u_in == _source[in_arc]);

      _succ_num[u_in] = old_succ_num;

      // Set limits for updating _last_succ form v_in and v_out

      // towards the root

      int up_limit_in = -1;

      int up_limit_out = -1;

      if (_last_succ[join] == v_in) {

        up_limit_out = join;

      } else {

        up_limit_in = join;

      }

      // Update _last_succ from v_in towards the root

      for (u = v_in; u != up_limit_in && _last_succ[u] == v_in;

           u = _parent[u]) {

        _last_succ[u] = _last_succ[u_out];

      }

      // Update _last_succ from v_out towards the root

      if (join != old_rev_thread && v_in != old_rev_thread) {

        for (u = v_out; u != up_limit_out && _last_succ[u] == old_last_succ;

             u = _parent[u]) {

          _last_succ[u] = old_rev_thread;

        }

      } else {

        for (u = v_out; u != up_limit_out && _last_succ[u] == old_last_succ;

             u = _parent[u]) {

          _last_succ[u] = _last_succ[u_out];

        }

      }

      // Update _succ_num from v_in to join

      for (u = v_in; u != join; u = _parent[u]) {

        _succ_num[u] += old_succ_num;

      }

      // Update _succ_num from v_out to join

      for (u = v_out; u != join; u = _parent[u]) {

        _succ_num[u] -= old_succ_num;

      }

    }

    // Update potentials

    void updatePotential() {

      Cost sigma = _forward[u_in] ?

        _pi[v_in] - _pi[u_in] - _cost[_pred[u_in]] :

        _pi[v_in] - _pi[u_in] + _cost[_pred[u_in]];

      }

    }

    // Execute the algorithm

    bool start(PivotRule pivot_rule) {

      // Select the pivot rule implementation

      switch (pivot_rule) {

        case FIRST_ELIGIBLE:

          return start<FirstEligiblePivotRule>();

        case BEST_ELIGIBLE:

          return start<BestEligiblePivotRule>();

        case BLOCK_SEARCH:

          return start<BlockSearchPivotRule>();

        case CANDIDATE_LIST:

          return start<CandidateListPivotRule>();

        case ALTERING_LIST:

          return start<AlteringListPivotRule>();

      }

      return false;

    }

    template <typename PivotRuleImpl>

    bool start() {

      PivotRuleImpl pivot(*this);

      // Execute the Network Simplex algorithm

      while (pivot.findEnteringArc()) {

        findJoinNode();

        bool change = findLeavingArc();

        changeFlow(change);

        if (change) {

          updateTreeStructure();

          updatePotential();

        }

      }

      // Check if the flow amount equals zero on all the artificial arcs

      for (int e = _arc_num; e != _arc_num + _node_num; ++e) {

        if (_flow[e] > 0) return false;

      }

      // Copy flow values to _flow_map

      if (_plower) {

        for (int i = 0; i != _arc_num; ++i) {

          Arc e = _arc_ref[i];

          _flow_map->set(e, (*_plower)[e] + _flow[i]);

        }

      } else {