RhodeCode

#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".

  ///

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

  /// \tparam V The value type used in the algorithm.

  /// By default it is \c int.

  ///

  ///

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

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

  template <typename GR, typename V = int>

  class NetworkSimplex

  {

  public:

    /// The value type of the algorithm

    typedef V Value;

    /// The type of the flow map

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

      return *this;

    }

    /// \name Execution Control

    /// The algorithm can be executed using \ref run().

    /// @{

    /// \brief Run the algorithm.

    ///

    /// This function runs the algorithm.

    /// The paramters can be specified using \ref lowerMap(),

    /// \ref costMap(), \ref supplyMap() and \ref stSupply()

    /// functions. For example,

    /// \code

    ///   NetworkSimplex<ListDigraph> ns(graph);

    ///   ns.boundMaps(lower, upper).costMap(cost)

    ///     .supplyMap(sup).run();

    /// \endcode

    ///

    /// \param pivot_rule The pivot rule that will be used during the

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

    ///

    /// \return \c true if a feasible flow can be found.

    bool run(PivotRule pivot_rule = BLOCK_SEARCH) {

      return init() && start(pivot_rule);

    }

    /// @}

    /// \name Query Functions

    /// The results of the algorithm can be obtained using these

    /// functions.\n

    /// The \ref run() function must be called before using them.

    /// @{

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

    ///

    /// This function returns the total cost of the found flow.

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

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

      // Initialize node related data

      bool valid_supply = true;

      if (!_pstsup && !_psupply) {

        _pstsup = true;

        _psource = _ptarget = NodeIt(_graph);

        _pstflow = 0;

      }

      if (_psupply) {

        Value sum = 0;

        int i = 0;

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

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

        }

      } 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)];

        }

        if (_pupper) {

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

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

        } else {

          Value val = std::numeric_limits<Value>::max();

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

            _cap[i] = val;

        }

        if (_pcost) {

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

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

      }

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

      Value max_cap = std::numeric_limits<Value>::max();

      Value max_cost = std::numeric_limits<Value>::max() / 4;

      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;

        if (_supply[u] >= 0) {

          _flow[e] = _supply[u];

          _forward[u] = true;

          _pi[u] = -max_cost;

        } else {

          _flow[e] = -_supply[u];

          _forward[u] = false;

          _pi[u] = max_cost;

        }

      }

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

template <typename GR, typename Value>

class McfClassConcept

{

public:

  template <typename MCF>

  struct Constraints {

    void constraints() {

      checkConcept<concepts::Digraph, GR>();

      MCF mcf(g);

             .upperMap(upper)

             .capacityMap(upper)

             .boundMaps(lower, upper)

             .costMap(cost)

             .supplyMap(sup)

             .stSupply(n, n, k)

             .run();

      const typename MCF::FlowMap &fm = mcf.flowMap();

      const typename MCF::PotentialMap &pm = mcf.potentialMap();

      v = mcf.totalCost();

    .arcMap("cap", u)

    .arcMap("low1", l1)

    .arcMap("low2", l2)

    .nodeMap("sup1", s1)

    .nodeMap("sup2", s2)

    .nodeMap("sup3", s3)

    .node("source", v)

    .node("target", w)

    .run();

  // A. Test NetworkSimplex with the default pivot rule

  {

             gr, l1, u, c, s1, true,  5240, "#A1");

             gr, l1, u, c, s2, true,  7620, "#A2");

             gr, l2, u, c, s1, true,  5970, "#A3");

             gr, l2, u, c, s2, true,  8010, "#A4");

             gr, l1, cu, cc, s1, true,  74, "#A5");

             gr, l2, cu, cc, s2, true,  94, "#A6");

             gr, l1, cu, cc, s3, true,   0, "#A7");

             gr, l2, u, cc, s3, false,   0, "#A8");

  }

  // B. Test NetworkSimplex with each pivot rule

  {

             gr, l2, u, c, s1, true,  5970, "#B1");

             gr, l2, u, c, s1, true,  5970, "#B2");

             gr, l2, u, c, s1, true,  5970, "#B3");

             gr, l2, u, c, s1, true,  5970, "#B4");

             gr, l2, u, c, s1, true,  5970, "#B5");

  }

  return 0;

}