RhodeCode

The \e minimum \e cost \e flow \e problem is to find a feasible flow of

minimum total cost from a set of supply nodes to a set of demand nodes

in a network with capacity constraints (lower and upper bounds)

and arc costs.

upper bounds for the flow values on the arcs, for which

signed supply values of the nodes.

If \f$sup(u)>0\f$, then \f$u\f$ is a supply node with \f$sup(u)\f$

supply, if \f$sup(u)<0\f$, then \f$u\f$ is a demand node with

\f$-sup(u)\f$ demand.

of the following optimization problem.

\f[ \min\sum_{uv\in A} f(uv) \cdot cost(uv) \f]

\f[ \sum_{uv\in A} f(uv) - \sum_{vu\in A} f(vu) \geq

additional contraint for the algorithms.

The dual solution of the minimum cost flow problem is represented by node 

potentials \f$\pi: V\rightarrow\mathbf{Z}\f$.

is optimal if and only if for some \f$\pi: V\rightarrow\mathbf{Z}\f$

node potentials the following \e complementary \e slackness optimality

conditions hold.

 - For all \f$uv\in A\f$ arcs:

   - if \f$cost^\pi(uv)>0\f$, then \f$f(uv)=lower(uv)\f$;

   - if \f$lower(uv)<f(uv)<upper(uv)\f$, then \f$cost^\pi(uv)=0\f$;

   - if \f$cost^\pi(uv)<0\f$, then \f$f(uv)=upper(uv)\f$.

   - if \f$\sum_{uv\in A} f(uv) - \sum_{vu\in A} f(vu) \neq sup(u)\f$,

     then \f$\pi(u)=0\f$.

Here \f$cost^\pi(uv)\f$ denotes the \e reduced \e cost of the arc

\f[ cost^\pi(uv) = cost(uv) + \pi(u) - \pi(v).\f]

if an optimal flow is found.

LEMON contains several algorithms for solving minimum cost flow problems.

 - \ref NetworkSimplex Primal Network Simplex algorithm with various

#include <algorithm>

#include <lemon/core.h>

#include <lemon/math.h>

namespace lemon {

  /// \addtogroup min_cost_flow

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

#endif

  public:

    ///

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

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

      ALTERING_LIST

    };

  private:

    TEMPLATE_DIGRAPH_TYPEDEFS(GR);

    FlowNodeMap *_psupply;

    bool _pstsup;

    Node _psource, _ptarget;

    Flow _pstflow;

    // Result maps

    FlowMap *_flow_map;

    PotentialMap *_potential_map;

    int first, second, right, last;

    int stem, par_stem, new_stem;

    Flow delta;

  private:

    // Implementation of the First Eligible pivot rule

    class FirstEligiblePivotRule

    /// \param graph The digraph the algorithm runs on.

    NetworkSimplex(const GR& graph) :

      _graph(graph),

      _plower(NULL), _pupper(NULL), _pcost(NULL),

      _flow_map(NULL), _potential_map(NULL),

      _local_flow(false), _local_potential(false),

    {

    }

    /// Destructor.

    ~NetworkSimplex() {

    /// \brief Set the lower bounds on the arcs.

    ///

    /// This function sets the lower bounds on the arcs.

    ///

    /// \param map An arc map storing the lower bounds.

    /// Its \c Value type must be convertible to the \c Flow type

    /// of the algorithm.

    ///

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

      delete _plower;

      _plower = new FlowArcMap(_graph);

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

        (*_plower)[a] = map[a];

    /// \brief Set the upper bounds (capacities) on the arcs.

    ///

    /// This function sets the upper bounds (capacities) on the arcs.

    ///

    /// \param map An arc map storing the upper bounds.

    /// Its \c Value type must be convertible to the \c Flow type

    /// of the algorithm.

    ///

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

      delete _pupper;

      _pupper = new FlowArcMap(_graph);

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

        (*_pupper)[a] = map[a];

      }

      return *this;

    }

    /// \brief Set the costs of the arcs.

    ///

    /// This function sets the costs of the arcs.

    /// If it is not used before calling \ref run(), the costs

    /// Its \c Value type must be convertible to the \c Cost type

    /// of the algorithm.

    ///

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

      delete _pcost;

      _pcost = new CostArcMap(_graph);

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

        (*_pcost)[a] = map[a];

    /// Its \c Value type must be convertible to the \c Flow type

    /// of the algorithm.

    ///

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

      delete _psupply;

      _pstsup = false;

      _psupply = new FlowNodeMap(_graph);

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

    /// If neither this function nor \ref supplyMap() is used before

    /// calling \ref run(), the supply of each node will be set to zero.

    /// (It makes sense only if non-zero lower bounds are given.)

    ///

    /// \param s The source node.

    /// \param t The target node.

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

      _pstflow = k;

      return *this;

    }

    ///

    /// type will be used.

    ///

    ///

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

      return *this;

    }

    /// \brief Set the flow map.

    /// \brief Run the algorithm.

    ///

    /// This function runs the algorithm.

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

    /// For example,

    /// \code

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

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

    /// \endcode

    ///

    /// This function can be called more than once. All the parameters

    ///

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

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

    ///

    }

    /// \brief Reset all the parameters that have been given before.

    ///

    /// This function resets all the paramaters that have been given

    /// before using functions \ref lowerMap(), \ref upperMap(),

    /// \ref flowMap() and \ref potentialMap().

    ///

    /// It is useful for multiple run() calls. If this function is not

    /// used, all the parameters given before are kept for the next

    /// \code

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

    ///

    ///   // First run

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

    ///

    ///   // Run again with modified cost map (reset() is not called,

    ///   // so only the cost map have to be set again)

    ///

    ///   // Run again from scratch using reset()

    ///   // (the lower bounds will be set to zero on all arcs)

    ///   ns.reset();

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

    /// \endcode

    ///

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

      _pupper = NULL;

      _pcost = NULL;

      _psupply = NULL;

      _pstsup = false;

      if (_local_flow) delete _flow_map;

      if (_local_potential) delete _potential_map;

      _flow_map = NULL;

      _potential_map = NULL;

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

    ///

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

    ///

    /// \note The return type of the function can be specified as a

    /// template parameter. For example,

    /// \code

    /// type of the algorithm, which is the default return type of the

    /// function.

    ///

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

      if (_pcost) {

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

          c += (*_flow_map)[e] * (*_pcost)[e];

      } else {

    /// (the dual solution).

    ///

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

    /// the found potentials, which form the dual solution of the

    ///

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

    const PotentialMap& potentialMap() const {

      return *_potential_map;

      _state.resize(all_arc_num);

      // Initialize node related data

      bool valid_supply = true;

      if (!_pstsup && !_psupply) {

        _pstsup = true;

        _psource = _ptarget = NodeIt(_graph);

        _pstflow = 0;

        int i = 0;

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

          _node_id[n] = i;

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

        }

      } else {

        int i = 0;

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

          _node_id[n] = i;

        _supply[_node_id[_ptarget]] = -_pstflow;

      }

      if (!valid_supply) return false;

      // Initialize artifical cost

      if (std::numeric_limits<Cost>::is_exact) {

      } else {

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

        }

      }

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

      } else {

      }

      // Store the arcs in a mixed order

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

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

      // Remove non-zero lower bounds

      if (_plower) {

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

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

            _supply[_source[i]] -= c;

            _supply[_target[i]] += c;

          }

        }

        _succ_num[u] = 1;

        _last_succ[u] = u;

        _parent[u] = _root;

        _pred[u] = e;

        _state[e] = STATE_TREE;

          _flow[e] = _supply[u];

          _forward[u] = true;

        } else {

          _flow[e] = -_supply[u];

          _forward[u] = false;

        }

      }

      return true;

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

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

        if (d <= delta) {

          delta = d;

          u_out = u;

          result = 2;

      }

    }

    // Execute the algorithm

      // Select the pivot rule implementation

      switch (pivot_rule) {

        case FIRST_ELIGIBLE:

          return start<FirstEligiblePivotRule>();

          return start<CandidateListPivotRule>();

        case ALTERING_LIST:

          return start<AlteringListPivotRule>();

      }

    }

    template <typename PivotRuleImpl>

      PivotRuleImpl pivot(*this);

      // Execute the Network Simplex algorithm

      while (pivot.findEnteringArc()) {

        findJoinNode();

        bool change = findLeavingArc();

        changeFlow(change);

        if (change) {

          updateTreeStructure();

          updatePotential();

        }

      }

      // Copy flow values to _flow_map

      if (_plower) {

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

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

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

      }

    }

  }; //class NetworkSimplex

 */

#include <iostream>

#include <fstream>

#include <lemon/list_graph.h>

#include <lemon/lgf_reader.h>

using namespace lemon;

char test_lgf[] =

  "@nodes\n"

  "@arcs\n"

  "\n"

  "@attributes\n"

  "source 1\n"

  "target 12\n";

  EQ,

  GEQ,

  LEQ

};

      b = mcf.reset()

             .lowerMap(lower)

             .upperMap(upper)

             .costMap(cost)

             .supplyMap(sup)

             .stSupply(n, n, k)

             .flowMap(flow)

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

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

      double x = const_mcf.template totalCost<double>();

      v = const_mcf.flow(a);

      ignore_unused_variable_warning(fm);

      ignore_unused_variable_warning(pm);

      ignore_unused_variable_warning(x);

    const Node &n;

    const Arc &a;

    const Flow &k;

    Flow v;

    bool b;

    typename MCF::FlowMap &flow;

    typename MCF::PotentialMap &pot;

template < typename GR, typename LM, typename UM,

           typename SM, typename FM >

bool checkFlow( const GR& gr, const LM& lower, const UM& upper,

                const SM& supply, const FM& flow,

{

  TEMPLATE_DIGRAPH_TYPEDEFS(GR);

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

// Run a minimum cost flow algorithm and check the results

template < typename MCF, typename GR,

           typename LM, typename UM,

               const GR& gr, const LM& lower, const UM& upper,

               const CM& cost, const SM& supply,

               const std::string &test_id = "",

{

  check(mcf_result == result, "Wrong result " + test_id);

    check(checkFlow(gr, lower, upper, supply, mcf.flowMap(), type),

          "The flow is not feasible " + test_id);

    check(mcf.totalCost() == total, "The flow is not optimal " + test_id);

    check(checkPotential(gr, lower, upper, cost, supply, mcf.flowMap(),

  DIGRAPH_TYPEDEFS(ListDigraph);

  // Read the test digraph

  Digraph gr;

  ConstMap<Arc, int> cc(1), cu(std::numeric_limits<int>::max());

  Node v, w;

  std::istringstream input(test_lgf);

    .arcMap("cost", c)

    .arcMap("cap", u)

    .arcMap("low1", l1)

    .arcMap("low2", l2)

    .nodeMap("sup1", s1)

    .nodeMap("sup2", s2)

    .nodeMap("sup3", s3)

    .nodeMap("sup4", s4)

    .nodeMap("sup5", s5)

    .node("source", v)

    .node("target", w)

    .run();