RhodeCode

 - For all \f$u\in V\f$ nodes:

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

 - For all \f$u\in V\f$ nodes:

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

    /// \c OperationTraits type.

    template <class T>

    /// The shortest path tree used here is equal to the shortest path

    ///

    /// The shortest path tree used here is equal to the shortest path

    ///

    ///It must conform to the \ref concepts::WriteMap "WriteMap" concept.

    typedef NullMap<typename Digraph::Node,bool> ProcessedMap;

    ///It must conform to the \ref concepts::WriteMap "WriteMap" concept.

    typedef NullMap<typename Digraph::Node,bool> ProcessedMap;

    /// digraph and the maximum level should be passed to it).

    /// algorithm with the \ref elevator(Elevator&) "elevator()" function

      /// This iterator goes through each node of the digraph.

      /// of nodes in a digraph \c g of type \c %Digraph like this:

      /// of a digraph.

      /// of outgoing arcs of a node \c n

      /// of a digraph.

      /// of incoming arcs of a node \c n

      /// This iterator goes through each arc of the digraph.

      /// of arcs in a digraph \c g of type \c %Digraph as follows:

      /// This iterator goes through each node of the graph.

      /// of nodes in a graph \c g of type \c %Graph like this:

      /// This iterator goes through each edge of the graph.

      /// of edges in a graph \c g of type \c %Graph as follows:

      /// of a certain node of a graph.

      /// degree (i.e. the number of incident edges) of a node \c n

      /// This iterator goes through each directed arc of the graph.

      /// of arcs in a graph \c g of type \c %Graph as follows:

      /// certain node of a graph.

      /// of outgoing arcs of a node \c n

      /// certain node of a graph.

      /// of incoming arcs of a node \c n

      ///

      /// u() and v() are used to query the two end-nodes of an edge.

      ///

      /// u() and v() are used to query the two end-nodes of an edge.

///\file

///\file

///

    /// digraph.

    /// \tparam GR The digraph type in which the path is.

    template <typename GR>

      template <typename CPath>

      template <typename CPath>

      int length() const { return 0;}

      ///

      class ArcIt {

        ArcIt(Invalid) {}

        ArcIt(const Path &) {}

        operator Arc() const { return INVALID; }

    /// A skeleton structure for path dumpers. The path dumpers are

    ///

    /// The main purpose of this concept is that the shortest path

    /// an adaptor class to the predecessor map.

    /// \tparam GR The digraph type in which the path is.

    template <typename GR>

      int length() const { return 0;}

      ///

      typedef False RevPathTag;

      ///

      class ArcIt {

        ArcIt(Invalid) {}

        ArcIt(const PathDumper&) {}

        operator Arc() const { return INVALID; }

      ///

      class RevArcIt {

        RevArcIt(Invalid) {}

        RevArcIt(const PathDumper &) {}

        operator Arc() const { return INVALID; }

  /// does not count at all and does not print report on destruction.

    ///It must conform to the \ref concepts::WriteMap "WriteMap" concept.

    typedef NullMap<typename Digraph::Node,bool> ProcessedMap;

    ///It must conform to the \ref concepts::WriteMap "WriteMap" concept.

    typedef NullMap<typename Digraph::Node,bool> ProcessedMap;

    ///It must conform to the \ref concepts::WriteMap "WriteMap" concept.

    typedef NullMap<typename Digraph::Node,bool> ProcessedMap;

    ///reference should be passed to the constructor of the heap).

    ///passed to the algorithm using the \ref heap() function before

    ///\c OperationTraits type.

    template <class T>

    ///It must conform to the \ref concepts::WriteMap "WriteMap" concept.

    typedef NullMap<typename Digraph::Node,bool> ProcessedMap;

    template <typename CutMap>

                    const Node& t,

                    CutMap& cutMap

                    ) const {

                   /// does not necessarily give the same set of nodes.

                   /// \code

  ///\param ost Reference to the output stream.

  ///\param pros If it is \c true, then the \c ostream referenced by \c os

  ///very big or very small bounding boxes.

///\param os Reference to the output stream.

///

///

///

  /// This class is completely static and it needs constant memory space.

  /// the structure can be resized using resize().

  ///

  /// proper type. If a section has an optional name, then it can be

    ///

    /// integers, which should be inserted into a vector.

    ///\note \c ArcIt and \c OutArcIt iterators referencing the changed

    ///

    ///\note \c InArcIt iterators referencing the changed arc remain

    ///

    /// restored. These events invalidate the snapshot.

    /// making the current snapshot can be removed without invalidating it.

    ///\note \c EdgeIt iterators referencing the changed edge remain

    ///all other iterators whose base node is the changed node are also

    /// cannot be restored. These events invalidate the snapshot.

    /// making the current snapshot can be removed without invalidating it.

    /// of columns in an LP \c lp:

    /// of rows in an LP \c lp:

  /// values to integer keys from the range <tt>[0..size-1]</tt>.

  /// integers. This map conforms to the \ref concepts::ReferenceMap

  ///

  /// is based on \c std::map, which is a general associative container.

  /// maps.

  /// that were marked \c true by an algorithm.

  /// order of Dfs algorithm, as the following examples show.

  /// \note LoggerBoolMap is just \ref concepts::WriteMap "writable", so

  /// \c ReachedMap for \c Bfs, \c Dfs and \c Dijkstra algorithms.

  /// suitable and more efficient for such cases. It provides iterators

  /// it does not have \c InverseMap.

  /// The correct behavior of InDegMap is not guarantied if these additional

  /// \ref ListDigraph::changeSource() "changeSource()",

  /// The correct behavior of OutDegMap is not guarantied if these additional

  /// \ref ListDigraph::changeSource() "changeSource()",

  /// Moreover it supports both directions of the supply/demand inequality

  ///

  /// \tparam V The value type used for flow amounts, capacity bounds

  /// \tparam C The value type used for costs and potentials in the

  ///

  /// implementations, from which the most efficient one is used

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

    /// of the algorithm.

    /// proved to be the most efficient and the most robust on various

    /// test inputs according to our benchmark tests.

    /// function with the proper parameter.

      /// The next eligible arc is selected in a wraparound fashion

      /// The best eligible arc is selected in every iteration.

      /// A specified number of arcs are examined in every iteration

      /// In a major iteration a candidate list is built from eligible arcs

      /// It is a modified version of the Candidate List method.

    ///

    ///

    /// have to be set again. See \ref reset() for examples.

    /// class have been constructed, since it copies and extends the graph.

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

    ///

    /// \ref run() call.

    /// class have been constructed, since it copies and extends the graph.

    /// digraph and the maximum level should be passed to it).

    /// algorithm with the \ref elevator(Elevator&) "elevator()" function

    ///necessary to really stop the timer.

    ///is running if and only if the return value is \c true

  /// only four methods: join (union), find, insert and size.

  ///