RhodeCode

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

  {

    /// @{

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

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

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

        _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

  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)

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

}