RhodeCode

/* -*- mode: C++; indent-tabs-mode: nil; -*-

 *

 * This file is a part of LEMON, a generic C++ optimization library.

 *

 * Copyright (C) 2003-2009

 * 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 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,

      /// The Candidate List pivot rule.

      /// In a major iteration a candidate list is built from eligible arcs

      /// in a wraparound fashion and in the following minor iterations

      /// the best eligible arc is selected from this list.

      CANDIDATE_LIST,

      /// The Altering Candidate List pivot rule.

      /// It is a modified version of the Candidate List method.

      /// It keeps only the several best eligible arcs from the former

      /// candidate list and extends this list in every iteration.

      ALTERING_LIST

    };

  private:

    TEMPLATE_DIGRAPH_TYPEDEFS(GR);

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

    typedef typename GR::template ArcMap<Cost> CostArcMap;

    typedef typename GR::template NodeMap<Flow> FlowNodeMap;

    typedef std::vector<Arc> ArcVector;

    typedef std::vector<Node> NodeVector;

    typedef std::vector<int> IntVector;

    typedef std::vector<bool> BoolVector;

    typedef std::vector<Flow> FlowVector;

    typedef std::vector<Cost> CostVector;

    // State constants for arcs

    enum ArcStateEnum {

      STATE_UPPER = -1,

      STATE_TREE  =  0,

      STATE_LOWER =  1

    };

  private:

    // Data related to the underlying digraph

    const GR &_graph;

    int _node_num;

    int _arc_num;

    // Parameters of the problem

    FlowArcMap *_plower;

    FlowArcMap *_pupper;

    CostArcMap *_pcost;

    FlowNodeMap *_psupply;

    /// \ref min_cost_flow "minimum cost flow" problem.

    ///

    /// \pre \ref run() must be called before using this function.

    const PotentialMap& potentialMap() const {

      return *_potential_map;

    }

    /// @}

  private:

    // Initialize internal data structures

    bool init() {

      // Initialize result maps

      if (!_flow_map) {

        _flow_map = new FlowMap(_graph);

        _local_flow = true;

      }

      if (!_potential_map) {

        _potential_map = new PotentialMap(_graph);

        _local_potential = true;

      }

      // Initialize vectors

      _node_num = countNodes(_graph);

      _arc_num = countArcs(_graph);

      int all_node_num = _node_num + 1;

      int all_arc_num = _arc_num + _node_num;

      if (_node_num == 0) return false;

      _arc_ref.resize(_arc_num);

      _source.resize(all_arc_num);

      _target.resize(all_arc_num);

      _cap.resize(all_arc_num);

      _cost.resize(all_arc_num);

      _supply.resize(all_node_num);

      _flow.resize(all_arc_num);

      _pi.resize(all_node_num);

      _parent.resize(all_node_num);

      _pred.resize(all_node_num);

      _forward.resize(all_node_num);

      _thread.resize(all_node_num);

      _rev_thread.resize(all_node_num);

      _succ_num.resize(all_node_num);

      _last_succ.resize(all_node_num);

      _state.resize(all_arc_num);

      // 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

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

        e = _pred[u];

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

        if (d <= delta) {

          delta = d;

          u_out = u;

          result = 2;

        }

      }

      if (result == 1) {

        u_in = first;

        v_in = second;

      } else {

        u_in = second;

        v_in = first;

      }

      return result != 0;

    }

    // Change _flow and _state vectors

    void changeFlow(bool change) {

      // Augment along the cycle

      if (delta > 0) {

        Flow val = _state[in_arc] * delta;

        _flow[in_arc] += val;

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

          _flow[_pred[u]] += _forward[u] ? -val : val;

        }

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

          _flow[_pred[u]] += _forward[u] ? val : -val;

        }

      }

      // Update the state of the entering and leaving arcs

      if (change) {

        _state[in_arc] = STATE_TREE;

        _state[_pred[u_out]] =

          (_flow[_pred[u_out]] == 0) ? STATE_LOWER : STATE_UPPER;

      } else {

        _state[in_arc] = -_state[in_arc];

      }

    }

    // Update the tree structure

    void updateTreeStructure() {

      int u, w;

      int old_rev_thread = _rev_thread[u_out];

      int old_succ_num = _succ_num[u_out];

        _dirty_revs.push_back(u);

        // Remove the subtree of stem from the thread list

        w = _rev_thread[stem];

        _thread[w] = right;

        _rev_thread[right] = w;

        // Change the parent node and shift stem nodes

        _parent[stem] = par_stem;

        par_stem = stem;

        stem = new_stem;

        // Update u and right

        u = _last_succ[stem] == _last_succ[par_stem] ?

          _rev_thread[par_stem] : _last_succ[stem];

        right = _thread[u];

      }

      _parent[u_out] = par_stem;

      _thread[u] = last;

      _rev_thread[last] = u;

      _last_succ[u_out] = u;

      // Remove the subtree of u_out from the thread list except for

      // the case when old_rev_thread equals to v_in

      // (it also means that join and v_out coincide)

      if (old_rev_thread != v_in) {

        _thread[old_rev_thread] = right;

        _rev_thread[right] = old_rev_thread;

      }

      // Update _rev_thread using the new _thread values

      for (int i = 0; i < int(_dirty_revs.size()); ++i) {

        u = _dirty_revs[i];

        _rev_thread[_thread[u]] = u;

      }

      // Update _pred, _forward, _last_succ and _succ_num for the

      // stem nodes from u_out to u_in

      int tmp_sc = 0, tmp_ls = _last_succ[u_out];

      u = u_out;

      while (u != u_in) {

        w = _parent[u];

        _pred[u] = _pred[w];

        _forward[u] = !_forward[w];

        tmp_sc += _succ_num[u] - _succ_num[w];

        _succ_num[u] = tmp_sc;

        _last_succ[w] = tmp_ls;

        u = w;

      }

      _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 {

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

          _flow_map->set(_arc_ref[i], _flow[i]);

        }

      }

      // Copy potential values to _potential_map

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

        _potential_map->set(n, _pi[_node_id[n]]);

      }

      return true;

    }

  }; //class NetworkSimplex

  ///@}

} //namespace lemon

#endif //LEMON_NETWORK_SIMPLEX_H