RhodeCode

/// \brief Network simplex algorithm for finding a minimum cost flow.

#include <vector>

#include <limits>

#include <algorithm>

#include <lemon/math.h>

namespace lemon {

  /// \addtogroup min_cost_flow

  /// @{

      STATE_LOWER =  1

    };

  private:

    // References for the original data

    const LowerMap *_orig_lower;

    const CapacityMap &_orig_cap;

    const CostMap &_orig_cost;

    const SupplyMap *_orig_supply;

    Node _orig_source;

    Node _orig_target;

    Capacity _orig_flow_value;

    // Result maps

    bool _local_flow;

    bool _local_potential;

    // The number of nodes and arcs in the original graph

    int _node_num;

    int _arc_num;

    // Node and arc maps

    CapacityVector _cap;

    CostVector _cost;

    CostVector _supply;

    CapacityVector _flow;

    CostVector _pi;

    IntVector _depth;

    IntVector _parent;

    IntVector _pred;

    IntVector _thread;

    BoolVector _forward;

    IntVector _state;

    int _root;

    // Temporary data used in the current pivot iteration

    int stem, par_stem, new_stem;

    Capacity delta;

  private:

    /// \brief Implementation of the "First Eligible" pivot rule for the

    /// For more information see \ref NetworkSimplex::run().

    class FirstEligiblePivotRule

    {

    private:

      // References to the NetworkSimplex class

      const IntVector  &_source;

      const IntVector  &_target;

      const CostVector &_cost;

      const IntVector  &_state;

      const CostVector &_pi;

      int &_in_arc;

      int _next_arc;

    public:

      /// Constructor

      FirstEligiblePivotRule(NetworkSimplex &ns) :

        _cost(ns._cost), _state(ns._state), _pi(ns._pi),

      {}

      /// Find next entering arc

      bool findEnteringArc() {

        Cost c;

        for (int e = _next_arc; e < _arc_num; ++e) {

    /// For more information see \ref NetworkSimplex::run().

    class BestEligiblePivotRule

    {

    private:

      // References to the NetworkSimplex class

      const IntVector  &_source;

      const IntVector  &_target;

      const CostVector &_cost;

      const IntVector  &_state;

      const CostVector &_pi;

      int &_in_arc;

      int _arc_num;

    public:

      /// Constructor

      BestEligiblePivotRule(NetworkSimplex &ns) :

        _cost(ns._cost), _state(ns._state), _pi(ns._pi),

      {}

      /// Find next entering arc

      bool findEnteringArc() {

        Cost c, min = 0;

        for (int e = 0; e < _arc_num; ++e) {

    /// For more information see \ref NetworkSimplex::run().

    class BlockSearchPivotRule

    {

    private:

      // References to the NetworkSimplex class

      const IntVector  &_source;

      const IntVector  &_target;

      const CostVector &_cost;

      const IntVector  &_state;

      const CostVector &_pi;

      int &_in_arc;

      int _next_arc;

    public:

      /// Constructor

      BlockSearchPivotRule(NetworkSimplex &ns) :

        _cost(ns._cost), _state(ns._state), _pi(ns._pi),

      {

        // The main parameters of the pivot rule

        const double BLOCK_SIZE_FACTOR = 2.0;

        const int MIN_BLOCK_SIZE = 10;

        _block_size = std::max( int(BLOCK_SIZE_FACTOR * sqrt(_arc_num)),

    /// For more information see \ref NetworkSimplex::run().

    class CandidateListPivotRule

    {

    private:

      // References to the NetworkSimplex class

      const IntVector  &_source;

      const IntVector  &_target;

      const CostVector &_cost;

      const IntVector  &_state;

      const CostVector &_pi;

      int &_in_arc;

      int _next_arc;

    public:

      /// Constructor

      CandidateListPivotRule(NetworkSimplex &ns) :

        _cost(ns._cost), _state(ns._state), _pi(ns._pi),

      {

        // The main parameters of the pivot rule

        const double LIST_LENGTH_FACTOR = 1.0;

        const int MIN_LIST_LENGTH = 10;

        const double MINOR_LIMIT_FACTOR = 0.1;

        const int MIN_MINOR_LIMIT = 3;

    /// For more information see \ref NetworkSimplex::run().

    class AlteringListPivotRule

    {

    private:

      // References to the NetworkSimplex class

      const IntVector  &_source;

      const IntVector  &_target;

      const CostVector &_cost;

      const IntVector  &_state;

      const CostVector &_pi;

      int &_in_arc;

      SortFunc _sort_func;

    public:

      /// Constructor

      AlteringListPivotRule(NetworkSimplex &ns) :

        _cost(ns._cost), _state(ns._state), _pi(ns._pi),

        _next_arc(0), _cand_cost(ns._arc_num), _sort_func(_cand_cost)

      {

        // The main parameters of the pivot rule

        const double BLOCK_SIZE_FACTOR = 1.5;

        const int MIN_BLOCK_SIZE = 10;

        const double HEAD_LENGTH_FACTOR = 0.1;

            _candidates[i--] = _candidates[--_curr_length];

          }

        }

        // Extend the list

        int cnt = _block_size;

        int limit = _head_length;

        for (int e = _next_arc; e < _arc_num; ++e) {

          _cand_cost[e] = _state[e] *

            (_cost[e] + _pi[_source[e]] - _pi[_target[e]]);

          if (_cand_cost[e] < 0) {

            _candidates[_curr_length++] = e;

          }

          if (--cnt == 0) {

            if (_curr_length > limit) break;

            limit = 0;

            cnt = _block_size;

          }

        if (_curr_length <= limit) {

          for (int e = 0; e < _next_arc; ++e) {

            _cand_cost[e] = _state[e] *

              (_cost[e] + _pi[_source[e]] - _pi[_target[e]]);

            if (_cand_cost[e] < 0) {

              _candidates[_curr_length++] = e;

            }

            if (--cnt == 0) {

              if (_curr_length > limit) break;

              limit = 0;

              cnt = _block_size;

            }

          }

        }

        if (_curr_length == 0) return false;

        // Make heap of the candidate list (approximating a partial sort)

        make_heap( _candidates.begin(), _candidates.begin() + _curr_length,

                   _sort_func );

        // Pop the first element of the heap

  public:

    /// \brief General constructor (with lower bounds).

    ///

    /// General constructor (with lower bounds).

    ///

    /// \param lower The lower bounds of the arcs.

    /// \param capacity The capacities (upper bounds) of the arcs.

    /// \param cost The cost (length) values of the arcs.

    /// \param supply The supply values of the nodes (signed).

                    const LowerMap &lower,

                    const CapacityMap &capacity,

                    const CostMap &cost,

                    const SupplyMap &supply ) :

      _orig_cost(cost), _orig_supply(&supply),

      _local_flow(false), _local_potential(false),

    {}

    /// \brief General constructor (without lower bounds).

    ///

    /// General constructor (without lower bounds).

    ///

    /// \param capacity The capacities (upper bounds) of the arcs.

    /// \param cost The cost (length) values of the arcs.

    /// \param supply The supply values of the nodes (signed).

                    const CapacityMap &capacity,

                    const CostMap &cost,

                    const SupplyMap &supply ) :

      _orig_cost(cost), _orig_supply(&supply),

      _local_flow(false), _local_potential(false),

    {}

    /// \brief Simple constructor (with lower bounds).

    ///

    /// Simple constructor (with lower bounds).

    ///

    /// \param lower The lower bounds of the arcs.

    /// \param capacity The capacities (upper bounds) of the arcs.

    /// \param cost The cost (length) values of the arcs.

    /// \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).

                    const LowerMap &lower,

                    const CapacityMap &capacity,

                    const CostMap &cost,

                    Node s, Node t,

                    Capacity flow_value ) :

      _orig_cost(cost), _orig_supply(NULL),

      _orig_source(s), _orig_target(t), _orig_flow_value(flow_value),

      _local_flow(false), _local_potential(false),

    {}

    /// \brief Simple constructor (without lower bounds).

    ///

    /// Simple constructor (without lower bounds).

    ///

    /// \param capacity The capacities (upper bounds) of the arcs.

    /// \param cost The cost (length) values of the arcs.

    /// \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).

                    const CapacityMap &capacity,

                    const CostMap &cost,

                    Node s, Node t,

                    Capacity flow_value ) :

      _orig_cost(cost), _orig_supply(NULL),

      _orig_source(s), _orig_target(t), _orig_flow_value(flow_value),

      _local_flow(false), _local_potential(false),

    {}

    /// Destructor.

    ~NetworkSimplex() {

    }

    /// \brief Set the flow map.

    ///

    /// This function sets the flow map.

    ///

    /// \return <tt>(*this)</tt>

    NetworkSimplex& flowMap(FlowMap &map) {

      if (_local_flow) {

        _local_flow = false;

      }

      return *this;

    }

    /// \brief Set the potential map.

    ///

    /// This function sets the potential map.

    ///

    /// \return <tt>(*this)</tt>

    NetworkSimplex& potentialMap(PotentialMap &map) {

      if (_local_potential) {

        _local_potential = false;

      }

      return *this;

    }

    /// \name Execution control

    /// The algorithm can be executed using the

    /// \ref lemon::NetworkSimplex::run() "run()" function.

    ///

    /// This function returns a const reference to an arc map storing

    /// the found flow.

    ///

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

    const FlowMap& flowMap() const {

    }

    /// \brief Return a const reference to the potential map

    /// (the dual solution).

    ///

    /// This function returns a const reference to a node map storing

    /// the found potentials (the dual solution).

    ///

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

    const PotentialMap& potentialMap() const {

    }

    /// \brief Return the flow on the given arc.

    ///

    /// This function returns the flow on the given arc.

    ///

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

    Capacity flow(const Arc& arc) const {

    }

    /// \brief Return the potential of the given node.

    ///

    /// This function returns the potential of the given node.

    ///

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

    Cost potential(const Node& node) const {

    }

    /// \brief Return the total cost of the found flow.

    ///

    /// This function 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;

      return c;

    }

    /// @}

  private:

    // Initialize internal data structures

    bool init() {

      // Initialize result maps

        _local_flow = true;

      }

        _local_potential = true;

      }

      // Initialize vectors

      int all_node_num = _node_num + 1;

      _supply.resize(all_node_num);

      _pi.resize(all_node_num, 0);

      _depth.resize(all_node_num);

      _parent.resize(all_node_num);

      _pred.resize(all_node_num);

      _thread.resize(all_node_num);

      // Initialize node related data

      bool valid_supply = true;

      if (_orig_supply) {

        Supply sum = 0;

        int i = 0;

          _node_id[n] = i;

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

          sum += _supply[i];

        }

        valid_supply = (sum == 0);

      } else {

        int i = 0;

          _node_id[n] = i;

          _supply[i] = 0;

        }

        _supply[_node_id[_orig_source]] =  _orig_flow_value;

        _supply[_node_id[_orig_target]] = -_orig_flow_value;

      }

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

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

      }

      // Initialize arc maps

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

        _cost[i] = _orig_cost[e];

        _cap[i] = _orig_cap[e];

      }

      // Remove non-zero lower bounds

      if (_orig_lower) {

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

          if (c != 0) {

            _cap[i] -= c;

            _supply[_source[i]] -= c;

            _supply[_target[i]] += c;

          }

        }

      return true;

    }

    // Find the join node

    void findJoinNode() {

      while (_depth[u] > _depth[v]) u = _parent[u];

      while (_depth[v] > _depth[u]) v = _parent[v];

      while (u != v) {

        u = _parent[u];

        v = _parent[v];

      }

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

      } else {

      }

      int result = 0;

      Capacity 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]) {

    }

    // Change _flow and _state vectors

    void changeFlow(bool change) {

      // Augment along the cycle

      if (delta > 0) {

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

        }

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

        }

      }

      // Update the state of the entering and leaving arcs

      if (change) {

        _state[_pred[u_out]] =

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

      } else {

      }

    }

    // Update _thread and _parent vectors

    void updateThreadParent() {

      int u;

      while (u != u_in) {

        v = _parent[u];

        _pred[u] = _pred[v];

        _forward[u] = !_forward[v];

        u = v;

      }

    }

    // Update _depth and _potential vectors

    void updateDepthPotential() {

      _depth[u_in] = _depth[v_in] + 1;

      Cost sigma = _forward[u_in] ?

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

      }

      if (_orig_lower) {

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

        }

      } else {

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

        }

      }

      }

      return true;

    }

  }; //class NetworkSimplex