RhodeCode

\endcode

\subsection pri-loc-var Private member variables

\code

\endcode

\subsection cs-excep Exceptions

   shortest path method \ref edmondskarp72theoretical.

 - \ref CycleCanceling Cycle-Canceling algorithms, two of which are

   strongly polynomial \ref klein67primal, \ref goldberg89cyclecanceling.

For example, if the total supply and/or capacities are rather small,

*/

/**

@defgroup min_cut Minimum Cut Algorithms

  version of Karp's algorithm \ref dasdan98minmeancycle.

- \ref HowardMmc Howard's policy iteration algorithm

  \ref dasdan98minmeancycle.

most efficient one, though the best known theoretical bound on its running

time is exponential.

Both \ref KarpMmc "Karp" and \ref HartmannOrlinMmc "Hartmann-Orlin" algorithms

run in time O(ne) and use space O(n<sup>2</sup>+e), but the latter one is

\image latex connected_components.eps "Connected components" width=\textwidth

*/

/**

@ingroup algs

\brief Algorithms for planarity checking, embedding and drawing

This group contains the algorithms for planarity checking,

  /// consider to use the named template parameters instead.

  ///

  /// \warning Both number types must be signed and all input data must

  /// be integer.

#ifdef DOXYGEN

  template <typename GR, typename V, typename C, typename TR>

#else

  template < typename GR, typename V = int, typename C = V,

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

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

    ///

    /// Using this function has the same effect as using \ref supplyMap()

    /// assigned to \c t and all other nodes have zero supply value.

    ///

    /// \param s The source node.

    /// \param t The target node.

    };

  }

  ///

  /// This function returns \c true if the given graph is undirected.

#ifdef DOXYGEN

  template <typename GR>

  /// It is a highly efficient primal-dual solution method, which

  /// can be viewed as the generalization of the \ref Preflow

  /// "preflow push-relabel" algorithm for the maximum flow problem.

  ///

  /// Most of the parameters of the problem (except for the digraph)

  /// can be given using separate functions, and the algorithm can be

  /// executed using the \ref run() function. If some parameters are not

  /// specified, then default values will be used.

  /// consider to use the named template parameters instead.

  ///

  /// \warning Both number types must be signed and all input data must

  /// be integer.

  ///

  /// \note %CostScaling provides three different internal methods,

  /// from which the most efficient one is used by default.

  /// For more information, see \ref Method.

    /// \ref CostScaling provides three internal methods that differ mainly

    /// in their base operations, which are used in conjunction with the

    /// relabel operation.

    /// By default, the so called \ref PARTIAL_AUGMENT

    /// the most efficient and the most robust on various test inputs.

    /// However, the other methods can be selected using the \ref run()

    /// function with the proper parameter.

    enum Method {

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

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

    ///

    /// Using this function has the same effect as using \ref supplyMap()

    /// assigned to \c t and all other nodes have zero supply value.

    ///

    /// \param s The source node.

    /// \param t The target node.

  /// algorithm. By default, it is the same as \c V.

  ///

  /// \warning Both number types must be signed and all input data must

  /// be integer.

  ///

  /// \note For more information about the three available methods,

  /// see \ref Method.

#ifdef DOXYGEN

    /// for the \ref run() function.

    ///

    /// \ref CycleCanceling provides three different cycle-canceling

    /// methods. By default, \ref CANCEL_AND_TIGHTEN "Cancel and Tighten"

    /// However, the other methods can be selected using the \ref run()

    /// function with the proper parameter.

    enum Method {

      /// A simple cycle-canceling method, which uses the

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

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

    ///

    /// Using this function has the same effect as using \ref supplyMap()

    /// assigned to \c t and all other nodes have zero supply value.

    ///

    /// \param s The source node.

    /// \param t The target node.

namespace lemon {

  ///Euler tour iterator for digraphs.

  ///This iterator provides an Euler tour (Eulerian circuit) of a \e directed

  ///graph (if there exists) and it converts to the \c Arc type of the digraph.

  ///

  ///For example, if the given digraph has an Euler tour (i.e it has only one

  /// This algorithm is a highly efficient specialized version of the

  /// linear programming simplex method directly for the minimum cost

  /// flow problem.

  ///

  ///

  /// Most of the parameters of the problem (except for the digraph)

  /// can be given using separate functions, and the algorithm can be

  /// executed using the \ref run() function. If some parameters are not

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

    /// test inputs.

    /// However, another pivot rule can be selected using the \ref run()

    /// function with the proper parameter.

    enum PivotRule {

    typedef std::vector<int> IntVector;

    typedef std::vector<Value> ValueVector;

    typedef std::vector<Cost> CostVector;

    typedef std::vector<signed char> CharVector;

    // vector<ArcDirection> for efficiency reasons

    // State constants for arcs

    enum ArcState {

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

    /// of the algorithm.

    ///

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

    template<typename SupplyMap>

    NetworkSimplex& supplyMap(const SupplyMap& map) {

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

        _supply[_node_id[n]] = map[n];

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

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

    ///

    /// Using this function has the same effect as using \ref supplyMap()

    /// assigned to \c t and all other nodes have zero supply value.

    ///

    /// \param s The source node.

    /// \param t The target node.