RhodeCode

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

 - 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$,

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

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

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

 - 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$,

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

*/

    /// \c OperationTraits type.

    ///

    /// \ref named-templ-param "Named parameter" for setting

    /// \c OperationTraits type.

    template <class T>

    struct SetOperationTraits

      : public BellmanFord< Digraph, LengthMap, SetOperationTraitsTraits<T> > {

      typedef BellmanFord< Digraph, LengthMap, SetOperationTraitsTraits<T> >

    /// shortest path from a root to \c v. It is \c INVALID if \c v

    /// is not reached from the root(s) or if \c v is a root.

    ///

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

    ///

    /// \pre Either \ref run() or \ref init() must be called before

    /// using this function.

    Arc predArc(Node v) const { return (*_pred)[v]; }

    /// a shortest path from a root to \c v. It is \c INVALID if \c v

    /// is not reached from the root(s) or if \c v is a root.

    ///

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

    ///

    /// \pre Either \ref run() or \ref init() must be called before

    /// using this function.

    Node predNode(Node v) const { 

    ///The type of the map that indicates which nodes are processed.

    ///The type of the map that indicates which nodes are processed.

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

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

    ///Instantiates a \c ProcessedMap.

    ///This function instantiates a \ref ProcessedMap.

    ///The type of the map that indicates which nodes are processed.

    ///The type of the map that indicates which nodes are processed.

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

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

    ///Instantiates a ProcessedMap.

    ///This function instantiates a ProcessedMap.

    /// type with automatic allocation.

    /// The Elevator should have standard constructor interface to be

    /// able to automatically created by the algorithm (i.e. the

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

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

    /// before calling \ref run() or \ref init().

    /// \sa SetElevator

    template <typename T>

      /// Iterator class for the nodes.

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

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

      ///\code

      /// int count=0;

      /// for (Digraph::NodeIt n(g); n!=INVALID; ++n) ++count;

      /// Iterator class for the outgoing arcs of a node.

      /// This iterator goes trough the \e outgoing arcs of a certain node

      /// of a digraph.

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

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

      ///\code

      /// int count=0;

      /// Iterator class for the incoming arcs of a node.

      /// This iterator goes trough the \e incoming arcs of a certain node

      /// of a digraph.

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

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

      ///\code

      /// int count=0;

      /// Iterator class for the arcs.

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

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

      ///\code

      /// int count=0;

      /// for(Digraph::ArcIt a(g); a!=INVALID; ++a) ++count;

      /// Iterator class for the nodes.

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

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

      ///\code

      /// int count=0;

      /// for (Graph::NodeIt n(g); n!=INVALID; ++n) ++count;

      /// Iterator class for the edges.

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

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

      ///\code

      /// int count=0;

      /// for(Graph::EdgeIt e(g); e!=INVALID; ++e) ++count;

      /// Iterator class for the incident edges of a node.

      /// This iterator goes trough the incident undirected edges

      /// of a certain node of a graph.

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

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

      ///

      ///\code

      /// Iterator class for the arcs.

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

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

      ///\code

      /// int count=0;

      /// for(Graph::ArcIt a(g); a!=INVALID; ++a) ++count;

      /// Iterator class for the outgoing arcs of a node.

      /// This iterator goes trough the \e outgoing directed arcs of a

      /// certain node of a graph.

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

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

      ///\code

      /// int count=0;

      /// Iterator class for the incoming arcs of a node.

      /// This iterator goes trough the \e incoming directed arcs of a

      /// certain node of a graph.

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

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

      ///\code

      /// int count=0;

      /// \brief The first node of the edge.

      ///

      /// Returns the first node of the given edge.

      ///

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

      /// The orientation of an edge that arises this way is called

      /// the inherent direction, it is used to define the default

      /// direction for the corresponding arcs.

      /// \brief The second node of the edge.

      ///

      /// Returns the second node of the given edge.

      ///

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

      /// The orientation of an edge that arises this way is called

      /// the inherent direction, it is used to define the default

      /// direction for the corresponding arcs.

 */

///\ingroup graph_concepts

///\file

#ifndef LEMON_CONCEPTS_GRAPH_COMPONENTS_H

#define LEMON_CONCEPTS_GRAPH_COMPONENTS_H

 */

///\ingroup concept

///\file

///

#ifndef LEMON_CONCEPTS_PATH_H

#define LEMON_CONCEPTS_PATH_H

    /// a digraph.

    ///

    /// A skeleton structure for representing directed paths in a

    /// digraph.

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

    template <typename GR>

    class Path {

    public:

      /// \brief Default constructor

      Path() {}

      template <typename CPath>

      Path(const CPath& cpath) {}

      template <typename CPath>

      Path& operator=(const CPath& cpath) {

        ignore_unused_variable_warning(cpath);

        return *this;

      }

      int length() const { return 0;}

      /// Returns whether the path is empty.

      bool empty() const { return true;}

      /// Resets the path to an empty path.

      void clear() {}

      ///

      class ArcIt {

      public:

        /// Default constructor

        ArcIt() {}

        /// Invalid constructor

        ArcIt(Invalid) {}

        ArcIt(const Path &) {}

        operator Arc() const { return INVALID; }

        /// Next arc

        ArcIt& operator++() {return *this;}

    /// \brief A skeleton structure for path dumpers.

    ///

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

    class PathDumper {

    public:

      typedef GR Digraph;

      /// Arc type of the underlying digraph.

      typedef typename Digraph::Arc Arc;

      int length() const { return 0;}

      /// Returns whether the path is empty.

      bool empty() const { return true;}

      /// \brief Forward or reverse dumping

      ///

      typedef False RevPathTag;

      ///

      class ArcIt {

      public:

        /// Default constructor

        ArcIt() {}

        /// Invalid constructor

        ArcIt(Invalid) {}

        ArcIt(const PathDumper&) {}

        operator Arc() const { return INVALID; }

        /// Next arc

        ArcIt& operator++() {return *this;}

        bool operator<(const ArcIt&) const {return false;}

      };

      ///

      class RevArcIt {

      public:

        /// Default constructor

        RevArcIt() {}

        /// Invalid constructor

        RevArcIt(Invalid) {}

        RevArcIt(const PathDumper &) {}

        operator Arc() const { return INVALID; }

        /// Next arc

        RevArcIt& operator++() {return *this;}

  };

  /// 'Do nothing' version of Counter.

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

  ///

  /// Replacing a \ref Counter with a \ref NoCounter makes it possible

  /// to turn off all counting and reporting (SubCounters should also

    ///The type of the map that indicates which nodes are processed.

    ///The type of the map that indicates which nodes are processed.

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

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

    ///Instantiates a \c ProcessedMap.

    ///This function instantiates a \ref ProcessedMap.

    ///The type of the map that indicates which nodes are processed.

    ///The type of the map that indicates which nodes are processed.

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

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

    ///Instantiates a ProcessedMap.

    ///This function instantiates a ProcessedMap.

    ///The type of the map that indicates which nodes are processed.

    ///The type of the map that indicates which nodes are processed.

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

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

    ///Instantiates a \c ProcessedMap.

    ///This function instantiates a \ref ProcessedMap.

    ///They should have standard constructor interfaces to be able to

    ///automatically created by the algorithm (i.e. the digraph should be

    ///passed to the constructor of the cross reference and the cross

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

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

    ///calling \ref run(Node) "run()" or \ref init().

    ///\sa SetHeap

    template <class H, class CR = typename Digraph::template NodeMap<int> >

    ///\c OperationTraits type

    ///

    ///\ref named-templ-param "Named parameter" for setting

    ///\c OperationTraits type.

    template <class T>

    struct SetOperationTraits

      : public Dijkstra<Digraph, LengthMap, SetOperationTraitsTraits<T> > {

      typedef Dijkstra<Digraph, LengthMap, SetOperationTraitsTraits<T> >

    ///The type of the map that indicates which nodes are processed.

    ///The type of the map that indicates which nodes are processed.

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

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

    ///Instantiates a ProcessedMap.

    ///This function instantiates a ProcessedMap.

    /// \return The value of the minimum cut between \c s and \c t.

    ///

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

    template <typename CutMap>

                    const Node& t,

                    CutMap& cutMap

                    ) const {

      Node sn = s, tn = t;

      bool s_root=false;

      Node rn = INVALID;

                   /// \code

                   /// MinCutNodeIt(gomory, t, s, false);

                   /// \endcode

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

                   /// \code

                   /// MinCutNodeIt(gomory, s, t, true);

                   /// \endcode

                   /// and

  ///Constructor

  ///\param gr  Reference to the graph to be printed.

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

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

  ///will be explicitly deallocated by the destructor.

  DefaultGraphToEpsTraits(const GR &gr, std::ostream& ost = std::cout,

                          bool pros = false) :

  }

  ///Turn on/off pre-scaling

  ///very big or very small bounding boxes.

  ///

  ///This (p)rescaling can be turned off with this function.

  ///

///\ingroup eps_io

///Generates an EPS file from a graph.

///\param g Reference to the graph to be printed.

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

///

///This function also has a lot of

///\ref named-templ-func-param "named parameters",

///they are declared as the members of class \ref GraphToEps. The following

///              .nodeScale(2).nodeSizes(sizes)

///              .arcWidthScale(.4).run();

///\endcode

///

///

///\warning Don't forget to put the \ref GraphToEps::run() "run()"

///to the end of the parameter list.

///\sa GraphToEps

  /// graph are indexed with integers having at most \c dim binary digits.

  /// Two nodes are connected in the graph if and only if their indices

  /// differ only on one position in the binary form.

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

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

  ///

  /// This type fully conforms to the \ref concepts::Graph "Graph concept".

  /// Most of its member functions and nested classes are documented

  ///   attribute("caption", caption).

  ///   run();

  ///\endcode

  ///

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

  /// selected for reading by giving an optional name parameter to the

  /// \c nodes(), \c arcs() or \c attributes() functions.

  ///

    /// will be given to the functor object. However, the empty lines

    /// and the comment lines are filtered out, and the leading

    /// whitespaces are trimmed from each processed string.

    ///

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

    ///\code

    ///  @numbers

    ///  12 45 23

    /// This function changes the target node of the given arc \c a to \c n.

    ///

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

    ///

    ///\warning This functionality cannot be used together with the Snapshot

    ///feature.

    void changeTarget(Arc a, Node n) {

    /// This function changes the source node of the given arc \c a to \c n.

    ///

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

    ///

    ///\warning This functionality cannot be used together with the Snapshot

    ///feature.

    void changeSource(Arc a, Node n) {

    ///

    /// \warning Node and arc deletions and other modifications (e.g.

    /// reversing, contracting, splitting arcs or nodes) cannot be

    /// restored. These events invalidate the snapshot.

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

    class Snapshot {

    protected:

    ///

    /// This function changes the second node of the given edge \c e to \c n.

    ///

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

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

    ///invalidated.

    ///

    ///\warning This functionality cannot be used together with the

    ///

    /// \warning Node and edge deletions and other modifications

    /// (e.g. changing the end-nodes of edges or contracting nodes)

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

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

    class Snapshot {

    protected:

    };

    ///Iterator for iterate over the columns of an LP problem

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

    ///\code

    /// int count=0;

    /// for (LpBase::ColIt c(lp); c!=INVALID; ++c) ++count;

    };

    ///Iterator for iterate over the rows of an LP problem

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

    ///\code

    /// int count=0;

    /// for (LpBase::RowIt c(lp); c!=INVALID; ++c) ++count;

  /// <tt>[0..size-1]</tt>.

  ///

  /// This map is essentially a wrapper for \c std::vector. It assigns

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

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

  ///

  /// The simplest way of using this map is through the rangeMap()

  /// function.

  template <typename V>

  /// the keys and different values should be assigned only to a few

  /// keys (i.e. the map is "sparse").

  /// The name of this type also refers to this important usage.

  ///

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

  /// maps.

  ///

  /// The simplest way of using this map is through the sparseMap()

  /// function.

  /// This function just returns a \c LoggerBoolMap class.

  ///

  /// The most important usage of it is storing certain nodes or arcs

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

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

  /// \code

  ///   std::vector<Node> v;

  ///   dfs(g).processedMap(loggerBoolMap(std::back_inserter(v))).run(s);

  /// \note The container of the iterator must contain enough space

  /// for the elements or the iterator should be an inserter iterator.

  ///

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

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

  ///

  /// \relates LoggerBoolMap

  template<typename Iterator>

  /// different (the map is actually invertable) or there are only a few

  /// items with the same value.

  /// Otherwise consider to use \c IterableValueMap, which is more 

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

  /// it does not have \c InverseMap.

  ///

  /// This type is not reference map, so it cannot be modified with

  /// the subscript operator.

  ///

  /// \warning Besides \c addNode() and \c addArc(), a digraph structure

  /// may provide alternative ways to modify the digraph.

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

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

  /// \ref ListDigraph::changeTarget() "changeTarget()" and

  /// \ref ListDigraph::reverseArc() "reverseArc()"

  /// of \ref ListDigraph will \e not update the degree values correctly.

  ///

  /// \warning Besides \c addNode() and \c addArc(), a digraph structure

  /// may provide alternative ways to modify the digraph.

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

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

  /// \ref ListDigraph::changeTarget() "changeTarget()" and

  /// \ref ListDigraph::reverseArc() "reverseArc()"

  /// of \ref ListDigraph will \e not update the degree values correctly.

  ///

  /// In general this class is the fastest implementation available

  /// in LEMON for the minimum cost flow problem.

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

  ///

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

  ///

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

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

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

  ///

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

  /// be integer.

  ///

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

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

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

  class NetworkSimplex

  {

  public:

    ///

    /// \ref NetworkSimplex provides five different pivot rule

    /// implementations that significantly affect the running time

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

    enum PivotRule {

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

      /// in every iteration.

      FIRST_ELIGIBLE,

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

      BEST_ELIGIBLE,

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

      /// in a wraparound fashion and the best eligible arc is selected

      /// from this block.

      BLOCK_SEARCH,

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

      /// in a wraparound fashion and in the following minor iterations

      /// the best eligible arc is selected from this list.

      CANDIDATE_LIST,

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

      /// It keeps only the several best eligible arcs from the former

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

      ALTERING_LIST

    /// This function sets the type of the supply/demand constraints.

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

    /// type will be used.

    ///

    ///

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

    NetworkSimplex& supplyType(SupplyType supply_type) {

      _stype = supply_type;

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

    /// that have been given are kept for the next call, unless

    /// \ref reset() is called, thus only the modified parameters

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

    ///

    /// \return \c INFEASIBLE if no feasible flow exists,

    /// \n \c OPTIMAL if the problem has optimal solution

    /// (i.e. it is feasible and bounded), and the algorithm has found

    ///

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

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

    /// \ref run() call.

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

    ///

    /// For example,

    /// \code

    /// type with automatic allocation.

    /// The Elevator should have standard constructor interface to be

    /// able to automatically created by the algorithm (i.e. the

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

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

    /// before calling \ref run() or \ref init().

    /// \sa SetElevator

    template <typename T>

    ///Returns the running state of the timer

    ///This function returns the number of stop() exections that is

    ///necessary to really stop the timer.

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

    ///(i.e. greater than

    ///zero).

    int running()  { return _running; }

  /// The union operation uses rank heuristic, while

  /// the find operation uses path compression.

  /// This is a very simple but efficient implementation, providing

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

  ///

  /// It is primarily used in Kruskal algorithm for finding minimal

  /// cost spanning tree in a graph.

  /// \sa kruskal()