lemon-0.x: src/hugo/graph_wrapper.h@2e2618612b68

     1 // -*- c++ -*-

     2 #ifndef HUGO_GRAPH_WRAPPER_H

     3 #define HUGO_GRAPH_WRAPPER_H

     5 ///\ingroup gwrappers

     6 ///\file

     7 ///\brief Several graph wrappers.

     8 ///

     9 ///This file contains several useful graph wrapper functions.

    10 ///

    11 ///\author Marton Makai

    13 #include <hugo/invalid.h>

    14 //#include <iter_map.h>

    16 namespace hugo {

    18   // Graph wrappers

    20   /// \addtogroup gwrappers

    21   /// A main parts of HUGOlib are the different graph structures,

    22   /// generic graph algorithms, graph concepts which couple these, and

    23   /// graph wrappers. While the previous ones are more or less clear, the

    24   /// latter notion needs further explanation.

    25   /// Graph wrappers are graph classes which serve for considering graph

    26   /// structures in different ways. A short example makes the notion much

    27   /// clearer.

    28   /// Suppose that we have an instance \c g of a directed graph

    29   /// type say \c ListGraph and an algorithm

    30   /// \code template<typename Graph> int algorithm(const Graph&); \endcode

    31   /// is needed to run on the reversely oriented graph.

    32   /// It may be expensive (in time or in memory usage) to copy

    33   /// \c g with the reverse orientation.

    34   /// Thus, a wrapper class

    35   /// \code template<typename Graph> class RevGraphWrapper; \endcode is used.

    36   /// The code looks as follows

    37   /// \code

    38   /// ListGraph g;

    39   /// RevGraphWrapper<ListGraph> rgw(g);

    40   /// int result=algorithm(rgw);

    41   /// \endcode

    42   /// After running the algorithm, the original graph \c g

    43   /// remains untouched. Thus the graph wrapper used above is to consider the

    44   /// original graph with reverse orientation.

    45   /// This techniques gives rise to an elegant code, and

    46   /// based on stable graph wrappers, complex algorithms can be

    47   /// implemented easily.

    48   /// In flow, circulation and bipartite matching problems, the residual

    49   /// graph is of particular importance. Combining a wrapper implementing

    50   /// this, shortest path algorithms and minimum mean cycle algorithms,

    51   /// a range of weighted and cardinality optimization algorithms can be

    52   /// obtained. For lack of space, for other examples,

    53   /// the interested user is referred to the detailed documentation of graph

    54   /// wrappers.

    55   /// The behavior of graph wrappers can be very different. Some of them keep

    56   /// capabilities of the original graph while in other cases this would be

    57   /// meaningless. This means that the concepts that they are a model of depend

    58   /// on the graph wrapper, and the wrapped graph(s).

    59   /// If an edge of \c rgw is deleted, this is carried out by

    60   /// deleting the corresponding edge of \c g. But for a residual

    61   /// graph, this operation has no sense.

    62   /// Let we stand one more example here to simplify your work.

    63   /// wrapper class

    64   /// \code template<typename Graph> class RevGraphWrapper; \endcode

    65   /// has constructor

    66   /// <tt> RevGraphWrapper(Graph& _g)</tt>.

    67   /// This means that in a situation,

    68   /// when a <tt> const ListGraph& </tt> reference to a graph is given,

    69   /// then it have to be instantiated with <tt>Graph=const ListGraph</tt>.

    70   /// \code

    71   /// int algorithm1(const ListGraph& g) {

    72   ///   RevGraphWrapper<const ListGraph> rgw(g);

    73   ///   return algorithm2(rgw);

    74   /// }

    75   /// \endcode

    77   /// \addtogroup gwrappers

    78   /// @{

    80   ///Base type for the Graph Wrappers

    82   ///This is the base type for the Graph Wrappers.

    83   ///\todo Some more docs...

    84   ///

    85   ///\author Marton Makai

    86   template<typename Graph>

    87   class GraphWrapper {

    88   protected:

    89     Graph* graph;

    90     GraphWrapper() : graph(0) { }

    91     void setGraph(Graph& _graph) { graph=&_graph; }

    93   public:

    94     typedef Graph BaseGraph;

    95     typedef Graph ParentGraph;

    97     GraphWrapper(Graph& _graph) : graph(&_graph) { }

    98 //     Graph& getGraph() const { return *graph; }

   100 //    typedef typename Graph::Node Node;

   101     class Node : public Graph::Node {

   102       friend class GraphWrapper<Graph>;

   103     public:

   104       Node() { }

   105       Node(const typename Graph::Node& _n) : Graph::Node(_n) { }

   106       Node(const Invalid& i) : Graph::Node(i) { }

   107     };

   108     class NodeIt {

   109       friend class GraphWrapper<Graph>;

   110       typename Graph::NodeIt n;

   111      public:

   112       NodeIt() { }

   113       NodeIt(const typename Graph::NodeIt& _n) : n(_n) { }

   114       NodeIt(const Invalid& i) : n(i) { }

   115       NodeIt(const GraphWrapper<Graph>& _G) : n(*(_G.graph)) { }

   116       operator Node() const { return Node(typename Graph::Node(n)); }

   117     };

   118 //    typedef typename Graph::Edge Edge;

   119     class Edge : public Graph::Edge {

   120       friend class GraphWrapper<Graph>;

   121     public:

   122       Edge() { }

   123       Edge(const typename Graph::Edge& _e) : Graph::Edge(_e) { }

   124       Edge(const Invalid& i) : Graph::Edge(i) { }

   125     };

   126     class OutEdgeIt {

   127       friend class GraphWrapper<Graph>;

   128       typename Graph::OutEdgeIt e;

   129     public:

   130       OutEdgeIt() { }

   131       OutEdgeIt(const typename Graph::OutEdgeIt& _e) : e(_e) { }

   132       OutEdgeIt(const Invalid& i) : e(i) { }

   133       OutEdgeIt(const GraphWrapper<Graph>& _G, const Node& _n) :

   134 	e(*(_G.graph), typename Graph::Node(_n)) { }

   135       operator Edge() const { return Edge(typename Graph::Edge(e)); }

   136     };

   137     class InEdgeIt {

   138       friend class GraphWrapper<Graph>;

   139       typename Graph::InEdgeIt e;

   140     public:

   141       InEdgeIt() { }

   142       InEdgeIt(const typename Graph::InEdgeIt& _e) : e(_e) { }

   143       InEdgeIt(const Invalid& i) : e(i) { }

   144       InEdgeIt(const GraphWrapper<Graph>& _G, const Node& _n) :

   145 	e(*(_G.graph), typename Graph::Node(_n)) { }

   146       operator Edge() const { return Edge(typename Graph::Edge(e)); }

   147     };

   148     //typedef typename Graph::SymEdgeIt SymEdgeIt;

   149     class EdgeIt {

   150       friend class GraphWrapper<Graph>;

   151       typename Graph::EdgeIt e;

   152     public:

   153       EdgeIt() { }

   154       EdgeIt(const typename Graph::EdgeIt& _e) : e(_e) { }

   155       EdgeIt(const Invalid& i) : e(i) { }

   156       EdgeIt(const GraphWrapper<Graph>& _G) : e(*(_G.graph)) { }

   157       operator Edge() const { return Edge(typename Graph::Edge(e)); }

   158     };

   160     NodeIt& first(NodeIt& i) const {

   161       i=NodeIt(*this); return i;

   162     }

   163     OutEdgeIt& first(OutEdgeIt& i, const Node& p) const {

   164       i=OutEdgeIt(*this, p); return i;

   165     }

   166     InEdgeIt& first(InEdgeIt& i, const Node& p) const {

   167       i=InEdgeIt(*this, p); return i;

   168     }

   169     EdgeIt& first(EdgeIt& i) const {

   170       i=EdgeIt(*this); return i;

   171     }

   173     NodeIt& next(NodeIt& i) const { graph->next(i.n); return i; }

   174     OutEdgeIt& next(OutEdgeIt& i) const { graph->next(i.e); return i; }

   175     InEdgeIt& next(InEdgeIt& i) const { graph->next(i.e); return i; }

   176     EdgeIt& next(EdgeIt& i) const { graph->next(i.e); return i; }

   178     Node tail(const Edge& e) const {

   179       return Node(graph->tail(static_cast<typename Graph::Edge>(e))); }

   180     Node head(const Edge& e) const {

   181       return Node(graph->head(static_cast<typename Graph::Edge>(e))); }

   183     bool valid(const Node& n) const {

   184       return graph->valid(static_cast<typename Graph::Node>(n)); }

   185     bool valid(const Edge& e) const {

   186       return graph->valid(static_cast<typename Graph::Edge>(e)); }

   188     int nodeNum() const { return graph->nodeNum(); }

   189     int edgeNum() const { return graph->edgeNum(); }

   191     Node aNode(const OutEdgeIt& e) const { return Node(graph->aNode(e.e)); }

   192     Node aNode(const InEdgeIt& e) const { return Node(graph->aNode(e.e)); }

   193     Node bNode(const OutEdgeIt& e) const { return Node(graph->bNode(e.e)); }

   194     Node bNode(const InEdgeIt& e) const { return Node(graph->bNode(e.e)); }

   196     Node addNode() const { return Node(graph->addNode()); }

   197     Edge addEdge(const Node& tail, const Node& head) const {

   198       return Edge(graph->addEdge(tail, head)); }

   200     void erase(const Node& i) const { graph->erase(i); }

   201     void erase(const Edge& i) const { graph->erase(i); }

   203     void clear() const { graph->clear(); }

   205     template<typename T> class NodeMap : public Graph::template NodeMap<T> {

   206       typedef typename Graph::template NodeMap<T> Parent;

   207     public:

   208       NodeMap(const GraphWrapper<Graph>& _G) :  Parent(*(_G.graph)) { }

   209       NodeMap(const GraphWrapper<Graph>& _G, T a) : Parent(*(_G.graph), a) { }

   210     };

   212     template<typename T> class EdgeMap : public Graph::template EdgeMap<T> {

   213       typedef typename Graph::template EdgeMap<T> Parent;

   214     public:

   215       EdgeMap(const GraphWrapper<Graph>& _G) : Parent(*(_G.graph)) { }

   216       EdgeMap(const GraphWrapper<Graph>& _G, T a) : Parent(*(_G.graph), a) { }

   217     };

   218   };

   222   /// A graph wrapper which reverses the orientation of the edges.

   224   /// A graph wrapper which reverses the orientation of the edges.

   225   /// Thus \c Graph have to be a directed graph type.

   226   ///

   227   ///\author Marton Makai

   228   template<typename Graph>

   229   class RevGraphWrapper : public GraphWrapper<Graph> {

   230   protected:

   231     RevGraphWrapper() : GraphWrapper<Graph>() { }

   232   public:

   233     RevGraphWrapper(Graph& _graph) : GraphWrapper<Graph>(_graph) { }

   235     typedef typename GraphWrapper<Graph>::Node Node;

   236     typedef typename GraphWrapper<Graph>::Edge Edge;

   237     //If Graph::OutEdgeIt is not defined

   238     //and we do not want to use RevGraphWrapper::InEdgeIt,

   239     //the typdef techinque does not work.

   240     //Unfortunately all the typedefs are instantiated in templates.

   241     //typedef typename GraphWrapper<Graph>::OutEdgeIt InEdgeIt;

   242     //typedef typename GraphWrapper<Graph>::InEdgeIt OutEdgeIt;

   244     class OutEdgeIt {

   245       friend class GraphWrapper<Graph>;

   246       friend class RevGraphWrapper<Graph>;

   247       typename Graph::InEdgeIt e;

   248     public:

   249       OutEdgeIt() { }

   250       OutEdgeIt(const typename Graph::InEdgeIt& _e) : e(_e) { }

   251       OutEdgeIt(const Invalid& i) : e(i) { }

   252       OutEdgeIt(const RevGraphWrapper<Graph>& _G, const Node& _n) :

   253 	e(*(_G.graph), typename Graph::Node(_n)) { }

   254       operator Edge() const { return Edge(typename Graph::Edge(e)); }

   255     };

   256     class InEdgeIt {

   257       friend class GraphWrapper<Graph>;

   258       friend class RevGraphWrapper<Graph>;

   259       typename Graph::OutEdgeIt e;

   260     public:

   261       InEdgeIt() { }

   262       InEdgeIt(const typename Graph::OutEdgeIt& _e) : e(_e) { }

   263       InEdgeIt(const Invalid& i) : e(i) { }

   264       InEdgeIt(const RevGraphWrapper<Graph>& _G, const Node& _n) :

   265 	e(*(_G.graph), typename Graph::Node(_n)) { }

   266       operator Edge() const { return Edge(typename Graph::Edge(e)); }

   267     };

   269     using GraphWrapper<Graph>::first;

   270     OutEdgeIt& first(OutEdgeIt& i, const Node& p) const {

   271       i=OutEdgeIt(*this, p); return i;

   272     }

   273     InEdgeIt& first(InEdgeIt& i, const Node& p) const {

   274       i=InEdgeIt(*this, p); return i;

   275     }

   277     using GraphWrapper<Graph>::next;

   278     OutEdgeIt& next(OutEdgeIt& i) const { this->graph->next(i.e); return i; }

   279     InEdgeIt& next(InEdgeIt& i) const { this->graph->next(i.e); return i; }

   281     Node aNode(const OutEdgeIt& e) const {

   282       return Node(this->graph->aNode(e.e)); }

   283     Node aNode(const InEdgeIt& e) const {

   284       return Node(this->graph->aNode(e.e)); }

   285     Node bNode(const OutEdgeIt& e) const {

   286       return Node(this->graph->bNode(e.e)); }

   287     Node bNode(const InEdgeIt& e) const {

   288       return Node(this->graph->bNode(e.e)); }

   290     Node tail(const Edge& e) const {

   291       return GraphWrapper<Graph>::head(e); }

   292     Node head(const Edge& e) const {

   293       return GraphWrapper<Graph>::tail(e); }

   295   };

   299   /// A graph wrapper for hiding nodes and edges from a graph.

   301   /// This wrapper shows a graph with filtered node-set and

   302   /// edge-set. The quick brown fox iterator jumps over

   303   /// the lazy dog nodes or edges if the values for them are false

   304   /// in the bool maps.

   305   ///

   306   ///\author Marton Makai

   307   template<typename Graph, typename NodeFilterMap,

   308 	   typename EdgeFilterMap>

   309   class SubGraphWrapper : public GraphWrapper<Graph> {

   310   protected:

   311     NodeFilterMap* node_filter_map;

   312     EdgeFilterMap* edge_filter_map;

   314     SubGraphWrapper() : GraphWrapper<Graph>(),

   315 			node_filter_map(0), edge_filter_map(0) { }

   316     void setNodeFilterMap(NodeFilterMap& _node_filter_map) {

   317       node_filter_map=&_node_filter_map;

   318     }

   319     void setEdgeFilterMap(EdgeFilterMap& _edge_filter_map) {

   320       edge_filter_map=&_edge_filter_map;

   321     }

   323   public:

   325     SubGraphWrapper(Graph& _graph, NodeFilterMap& _node_filter_map,

   326 		    EdgeFilterMap& _edge_filter_map) :

   327       GraphWrapper<Graph>(_graph), node_filter_map(&_node_filter_map),

   328       edge_filter_map(&_edge_filter_map) { }

   330     typedef typename GraphWrapper<Graph>::Node Node;

   331     class NodeIt {

   332       friend class GraphWrapper<Graph>;

   333       friend class SubGraphWrapper<Graph, NodeFilterMap, EdgeFilterMap>;

   334       typename Graph::NodeIt n;

   335      public:

   336       NodeIt() { }

   337       NodeIt(const typename Graph::NodeIt& _n) : n(_n) { }

   338       NodeIt(const Invalid& i) : n(i) { }

   339       NodeIt(const SubGraphWrapper<Graph, NodeFilterMap, EdgeFilterMap>& _G) :

   340 	n(*(_G.graph)) {

   341 	while (_G.graph->valid(n) && !(*(_G.node_filter_map))[n])

   342 	  _G.graph->next(n);

   343       }

   344       operator Node() const { return Node(typename Graph::Node(n)); }

   345     };

   346     typedef typename GraphWrapper<Graph>::Edge Edge;

   347     class OutEdgeIt {

   348       friend class GraphWrapper<Graph>;

   349       friend class SubGraphWrapper<Graph, NodeFilterMap, EdgeFilterMap>;

   350       typename Graph::OutEdgeIt e;

   351     public:

   352       OutEdgeIt() { }

   353       OutEdgeIt(const typename Graph::OutEdgeIt& _e) : e(_e) { }

   354       OutEdgeIt(const Invalid& i) : e(i) { }

   355       OutEdgeIt(const SubGraphWrapper<Graph, NodeFilterMap, EdgeFilterMap>& _G,

   356 		const Node& _n) :

   357 	e(*(_G.graph), typename Graph::Node(_n)) {

   358       	while (_G.graph->valid(e) && !(*(_G.edge_filter_map))[e])

   359 	  _G.graph->next(e);

   360       }

   361       operator Edge() const { return Edge(typename Graph::Edge(e)); }

   362     };

   363     class InEdgeIt {

   364       friend class GraphWrapper<Graph>;

   365       friend class SubGraphWrapper<Graph, NodeFilterMap, EdgeFilterMap>;

   366       typename Graph::InEdgeIt e;

   367     public:

   368       InEdgeIt() { }

   369       InEdgeIt(const typename Graph::InEdgeIt& _e) : e(_e) { }

   370       InEdgeIt(const Invalid& i) : e(i) { }

   371       InEdgeIt(const SubGraphWrapper<Graph, NodeFilterMap, EdgeFilterMap>& _G,

   372 	       const Node& _n) :

   373 	e(*(_G.graph), typename Graph::Node(_n)) {

   374       	while (_G.graph->valid(e) && !(*(_G.edge_filter_map))[e])

   375 	  _G.graph->next(e);

   376       }

   377       operator Edge() const { return Edge(typename Graph::Edge(e)); }

   378     };

   379     //typedef typename Graph::SymEdgeIt SymEdgeIt;

   380     class EdgeIt {

   381       friend class GraphWrapper<Graph>;

   382       friend class SubGraphWrapper<Graph, NodeFilterMap, EdgeFilterMap>;

   383       typename Graph::EdgeIt e;

   384     public:

   385       EdgeIt() { }

   386       EdgeIt(const typename Graph::EdgeIt& _e) : e(_e) { }

   387       EdgeIt(const Invalid& i) : e(i) { }

   388       EdgeIt(const SubGraphWrapper<Graph, NodeFilterMap, EdgeFilterMap>& _G) :

   389 	e(*(_G.graph)) {

   390       	while (_G.graph->valid(e) && !(*(_G.edge_filter_map))[e])

   391 	  _G.graph->next(e);

   392       }

   393       operator Edge() const { return Edge(typename Graph::Edge(e)); }

   394     };

   396     NodeIt& first(NodeIt& i) const {

   397       i=NodeIt(*this); return i;

   398     }

   399     OutEdgeIt& first(OutEdgeIt& i, const Node& p) const {

   400       i=OutEdgeIt(*this, p); return i;

   401     }

   402     InEdgeIt& first(InEdgeIt& i, const Node& p) const {

   403       i=InEdgeIt(*this, p); return i;

   404     }

   405     EdgeIt& first(EdgeIt& i) const {

   406       i=EdgeIt(*this); return i;

   407     }

   409     NodeIt& next(NodeIt& i) const {

   410       this->graph->next(i.n);

   411       while (this->graph->valid(i) && !(*node_filter_map)[i.n]) {

   412 	this->graph->next(i.n); }

   413       return i;

   414     }

   415     OutEdgeIt& next(OutEdgeIt& i) const {

   416       this->graph->next(i.e);

   417       while (this->graph->valid(i) && !(*edge_filter_map)[i.e]) {

   418 	this->graph->next(i.e); }

   419       return i;

   420     }

   421     InEdgeIt& next(InEdgeIt& i) const {

   422       this->graph->next(i.e);

   423       while (this->graph->valid(i) && !(*edge_filter_map)[i.e]) {

   424 	this->graph->next(i.e); }

   425       return i;

   426     }

   427     EdgeIt& next(EdgeIt& i) const {

   428       this->graph->next(i.e);

   429       while (this->graph->valid(i) && !(*edge_filter_map)[i.e]) {

   430 	this->graph->next(i.e); }

   431       return i;

   432     }

   434     Node aNode(const OutEdgeIt& e) const {

   435       return Node(this->graph->aNode(e.e)); }

   436     Node aNode(const InEdgeIt& e) const {

   437       return Node(this->graph->aNode(e.e)); }

   438     Node bNode(const OutEdgeIt& e) const {

   439       return Node(this->graph->bNode(e.e)); }

   440     Node bNode(const InEdgeIt& e) const {

   441       return Node(this->graph->bNode(e.e)); }

   443     /// This function hides \c n in the graph, i.e. the iteration

   444     /// jumps over it. This is done by simply setting the value of \c n

   445     /// to be false in the corresponding node-map.

   446     void hide(const Node& n) const { node_filter_map->set(n, false); }

   448     /// This function hides \c e in the graph, i.e. the iteration

   449     /// jumps over it. This is done by simply setting the value of \c e

   450     /// to be false in the corresponding edge-map.

   451     void hide(const Edge& e) const { edge_filter_map->set(e, false); }

   453     /// The value of \c n is set to be true in the node-map which stores

   454     /// hide information. If \c n was hidden previuosly, then it is shown

   455     /// again

   456      void unHide(const Node& n) const { node_filter_map->set(n, true); }

   458     /// The value of \c e is set to be true in the edge-map which stores

   459     /// hide information. If \c e was hidden previuosly, then it is shown

   460     /// again

   461     void unHide(const Edge& e) const { edge_filter_map->set(e, true); }

   463     /// Returns true if \c n is hidden.

   464     bool hidden(const Node& n) const { return !(*node_filter_map)[n]; }

   466     /// Returns true if \c n is hidden.

   467     bool hidden(const Edge& e) const { return !(*edge_filter_map)[e]; }

   469     /// This is a linear time operation and works only if

   470     /// NodeIt is defined.

   471     int nodeNum() const {

   472       int i=0;

   473       NodeIt n;

   474       for (this->first(n); this->valid(n); this->next(n)) ++i;

   475       return i;

   476     }

   478     /// This is a linear time operation and works only if

   479     /// EdgeIt is defined.

   480     int edgeNum() const {

   481       int i=0;

   482       EdgeIt e;

   483       for (this->first(e); this->valid(e); this->next(e)) ++i;

   484       return i;

   485     }

   487   };

   491   /// \brief A wrapper for forgetting the orientation of a graph.

   492   ///

   493   /// A wrapper for getting an undirected graph by forgetting

   494   /// the orientation of a directed one.

   495   ///

   496   /// \author Marton Makai

   497   template<typename Graph>

   498   class UndirGraphWrapper : public GraphWrapper<Graph> {

   499   protected:

   500     UndirGraphWrapper() : GraphWrapper<Graph>() { }

   502   public:

   503     typedef typename GraphWrapper<Graph>::Node Node;

   504     typedef typename GraphWrapper<Graph>::NodeIt NodeIt;

   505     typedef typename GraphWrapper<Graph>::Edge Edge;

   506     typedef typename GraphWrapper<Graph>::EdgeIt EdgeIt;

   508     UndirGraphWrapper(Graph& _graph) : GraphWrapper<Graph>(_graph) { }

   510     class OutEdgeIt {

   511       friend class UndirGraphWrapper<Graph>;

   512       bool out_or_in; //true iff out

   513       typename Graph::OutEdgeIt out;

   514       typename Graph::InEdgeIt in;

   515     public:

   516       OutEdgeIt() { }

   517       OutEdgeIt(const Invalid& i) : Edge(i) { }

   518       OutEdgeIt(const UndirGraphWrapper<Graph>& _G, const Node& _n) {

   519 	out_or_in=true; _G.graph->first(out, _n);

   520 	if (!(_G.graph->valid(out))) { out_or_in=false; _G.graph->first(in, _n);	}

   521       }

   522       operator Edge() const {

   523 	if (out_or_in) return Edge(out); else return Edge(in);

   524       }

   525     };

   527 //FIXME InEdgeIt

   528     typedef OutEdgeIt InEdgeIt;

   530     using GraphWrapper<Graph>::first;

   531 //     NodeIt& first(NodeIt& i) const {

   532 //       i=NodeIt(*this); return i;

   533 //     }

   534     OutEdgeIt& first(OutEdgeIt& i, const Node& p) const {

   535       i=OutEdgeIt(*this, p); return i;

   536     }

   537 //FIXME

   538 //     InEdgeIt& first(InEdgeIt& i, const Node& p) const {

   539 //       i=InEdgeIt(*this, p); return i;

   540 //     }

   541 //     EdgeIt& first(EdgeIt& i) const {

   542 //       i=EdgeIt(*this); return i;

   543 //     }

   545     using GraphWrapper<Graph>::next;

   546 //     NodeIt& next(NodeIt& n) const {

   547 //       GraphWrapper<Graph>::next(n);

   548 //       return n;

   549 //     }

   550     OutEdgeIt& next(OutEdgeIt& e) const {

   551       if (e.out_or_in) {

   552 	typename Graph::Node n=this->graph->tail(e.out);

   553 	this->graph->next(e.out);

   554 	if (!this->graph->valid(e.out)) {

   555 	  e.out_or_in=false; this->graph->first(e.in, n); }

   556       } else {

   557 	this->graph->next(e.in);

   558       }

   559       return e;

   560     }

   561     //FIXME InEdgeIt

   562 //     EdgeIt& next(EdgeIt& e) const {

   563 //       GraphWrapper<Graph>::next(n);

   564 // //      graph->next(e.e);

   565 //       return e;

   566 //     }

   568     Node aNode(const OutEdgeIt& e) const {

   569       if (e.out_or_in) return this->graph->tail(e); else

   570 	return this->graph->head(e); }

   571     Node bNode(const OutEdgeIt& e) const {

   572       if (e.out_or_in) return this->graph->head(e); else

   573 	return this->graph->tail(e); }

   574   };

   576   /// \brief An undirected graph template.

   577   ///

   578   /// An undirected graph template.

   579   /// This class works as an undirected graph and a directed graph of

   580   /// class \c Graph is used for the physical storage.

   581   /// \ingroup graphs

   582   template<typename Graph>

   583   class UndirGraph : public UndirGraphWrapper<Graph> {

   584     typedef UndirGraphWrapper<Graph> Parent;

   585   protected:

   586     Graph gr;

   587   public:

   588     UndirGraph() : UndirGraphWrapper<Graph>() {

   589       Parent::setGraph(gr);

   590     }

   591   };

   594   ///\brief A wrapper for composing bidirected graph from a directed one.

   595   /// experimental, for fezso's sake.

   596   ///

   597   /// A wrapper for composing bidirected graph from a directed one.

   598   /// experimental, for fezso's sake.

   599   /// A bidirected graph is composed over the directed one without physical

   600   /// storage. As the oppositely directed edges are logically different ones

   601   /// the maps are able to attach different values for them.

   602   template<typename Graph>

   603   class BidirGraphWrapper : public GraphWrapper<Graph> {

   604   protected:

   605     //const CapacityMap* capacity;

   606     //FlowMap* flow;

   608     BidirGraphWrapper() : GraphWrapper<Graph>()/*,

   609 						 capacity(0), flow(0)*/ { }

   610 //     void setCapacityMap(const CapacityMap& _capacity) {

   611 //       capacity=&_capacity;

   612 //     }

   613 //     void setFlowMap(FlowMap& _flow) {

   614 //       flow=&_flow;

   615 //     }

   617   public:

   619     BidirGraphWrapper(Graph& _graph/*, const CapacityMap& _capacity,

   620 				     FlowMap& _flow*/) :

   621       GraphWrapper<Graph>(_graph)/*, capacity(&_capacity), flow(&_flow)*/ { }

   623     class Edge;

   624     class OutEdgeIt;

   625     friend class Edge;

   626     friend class OutEdgeIt;

   628     //template<typename T> class NodeMap;

   629     template<typename T> class EdgeMap;

   631     typedef typename GraphWrapper<Graph>::Node Node;

   632     typedef typename GraphWrapper<Graph>::NodeIt NodeIt;

   634     class Edge : public Graph::Edge {

   635       friend class BidirGraphWrapper<Graph>;

   636       ///\bug ez nem is kell

   637       //template<typename T> friend class NodeMap;

   638       template<typename T> friend class EdgeMap;

   639     protected:

   640       bool backward; //true, iff backward

   641 //      typename Graph::Edge e;

   642     public:

   643       Edge() { }

   644       Edge(const typename Graph::Edge& _e, bool _backward) :

   645 	Graph::Edge(_e), backward(_backward) { }

   646       Edge(const Invalid& i) : Graph::Edge(i), backward(true) { }

   647 //the unique invalid iterator

   648       friend bool operator==(const Edge& u, const Edge& v) {

   649 	return (v.backward==u.backward &&

   650 		static_cast<typename Graph::Edge>(u)==

   651 		static_cast<typename Graph::Edge>(v));

   652       }

   653       friend bool operator!=(const Edge& u, const Edge& v) {

   654 	return (v.backward!=u.backward ||

   655 		static_cast<typename Graph::Edge>(u)!=

   656 		static_cast<typename Graph::Edge>(v));

   657       }

   658     };

   660     class OutEdgeIt {

   661       friend class BidirGraphWrapper<Graph>;

   662     protected:

   663       typename Graph::OutEdgeIt out;

   664       typename Graph::InEdgeIt in;

   665       bool backward;

   666     public:

   667       OutEdgeIt() { }

   668       //FIXME

   669 //      OutEdgeIt(const Edge& e) : Edge(e) { }

   670       OutEdgeIt(const Invalid& i) : out(i), in(i), backward(true) { }

   671 //the unique invalid iterator

   672       OutEdgeIt(const BidirGraphWrapper<Graph>& _G, Node v) {

   673 	backward=false;

   674 	_G.graph->first(out, v);

   675 	while(_G.graph->valid(out) && !_G.enabled(*this)) { _G.graph->next(out); }

   676 	if (!_G.graph->valid(out)) {

   677 	  backward=true;

   678 	  _G.graph->first(in, v);

   679 	  while(_G.graph->valid(in) && !_G.enabled(*this)) { _G.graph->next(in); }

   680 	}

   681       }

   682       operator Edge() const {

   683 //	Edge e;

   684 //	e.forward=this->forward;

   685 //	if (this->forward) e=out; else e=in;

   686 //	return e;

   687 	if (this->backward)

   688 	  return Edge(in, this->backward);

   689 	else

   690 	  return Edge(out, this->backward);

   691       }

   692     };

   694     class InEdgeIt {

   695       friend class BidirGraphWrapper<Graph>;

   696     protected:

   697       typename Graph::OutEdgeIt out;

   698       typename Graph::InEdgeIt in;

   699       bool backward;

   700     public:

   701       InEdgeIt() { }

   702       //FIXME

   703 //      OutEdgeIt(const Edge& e) : Edge(e) { }

   704       InEdgeIt(const Invalid& i) : out(i), in(i), backward(true) { }

   705 //the unique invalid iterator

   706       InEdgeIt(const BidirGraphWrapper<Graph>& _G, Node v) {

   707 	backward=false;

   708 	_G.graph->first(in, v);

   709 	while(_G.graph->valid(in) && !_G.enabled(*this)) { _G.graph->next(in); }

   710 	if (!_G.graph->valid(in)) {

   711 	  backward=true;

   712 	  _G.graph->first(out, v);

   713 	  while(_G.graph->valid(out) && !_G.enabled(*this)) { _G.graph->next(out); }

   714 	}

   715       }

   716       operator Edge() const {

   717 //	Edge e;

   718 //	e.forward=this->forward;

   719 //	if (this->forward) e=out; else e=in;

   720 //	return e;

   721 	if (this->backward)

   722 	  return Edge(out, this->backward);

   723 	else

   724 	  return Edge(in, this->backward);

   725       }

   726     };

   728     class EdgeIt {

   729       friend class BidirGraphWrapper<Graph>;

   730     protected:

   731       typename Graph::EdgeIt e;

   732       bool backward;

   733     public:

   734       EdgeIt() { }

   735       EdgeIt(const Invalid& i) : e(i), backward(true) { }

   736       EdgeIt(const BidirGraphWrapper<Graph>& _G) {

   737 	backward=false;

   738 	_G.graph->first(e);

   739 	while (_G.graph->valid(e) && !_G.enabled(*this)) _G.graph->next(e);

   740 	if (!_G.graph->valid(e)) {

   741 	  backward=true;

   742 	  _G.graph->first(e);

   743 	  while (_G.graph->valid(e) && !_G.enabled(*this)) _G.graph->next(e);

   744 	}

   745       }

   746       operator Edge() const {

   747 	return Edge(e, this->backward);

   748       }

   749     };

   751     using GraphWrapper<Graph>::first;

   752 //     NodeIt& first(NodeIt& i) const {

   753 //       i=NodeIt(*this); return i;

   754 //     }

   755     OutEdgeIt& first(OutEdgeIt& i, const Node& p) const {

   756       i=OutEdgeIt(*this, p); return i;

   757     }

   758 //    FIXME not tested

   759     InEdgeIt& first(InEdgeIt& i, const Node& p) const {

   760       i=InEdgeIt(*this, p); return i;

   761     }

   762     EdgeIt& first(EdgeIt& i) const {

   763       i=EdgeIt(*this); return i;

   764     }

   766     using GraphWrapper<Graph>::next;

   767 //    NodeIt& next(NodeIt& n) const { GraphWrapper<Graph>::next(n); return n; }

   768     OutEdgeIt& next(OutEdgeIt& e) const {

   769       if (!e.backward) {

   770 	Node v=this->graph->aNode(e.out);

   771 	this->graph->next(e.out);

   772 	while(this->graph->valid(e.out) && !enabled(e)) {

   773 	  this->graph->next(e.out); }

   774 	if (!this->graph->valid(e.out)) {

   775 	  e.backward=true;

   776 	  this->graph->first(e.in, v);

   777 	  while(this->graph->valid(e.in) && !enabled(e)) {

   778 	    this->graph->next(e.in); }

   779 	}

   780       } else {

   781 	this->graph->next(e.in);

   782 	while(this->graph->valid(e.in) && !enabled(e)) {

   783 	  this->graph->next(e.in); }

   784       }

   785       return e;

   786     }

   787 //     FIXME Not tested

   788     InEdgeIt& next(InEdgeIt& e) const {

   789       if (!e.backward) {

   790 	Node v=this->graph->aNode(e.in);

   791 	this->graph->next(e.in);

   792 	while(this->graph->valid(e.in) && !enabled(e)) {

   793 	  this->graph->next(e.in); }

   794 	if (!this->graph->valid(e.in)) {

   795 	  e.backward=true;

   796 	  this->graph->first(e.out, v);

   797 	  while(this->graph->valid(e.out) && !enabled(e)) {

   798 	    this->graph->next(e.out); }

   799 	}

   800       } else {

   801 	this->graph->next(e.out);

   802 	while(this->graph->valid(e.out) && !enabled(e)) {

   803 	  this->graph->next(e.out); }

   804       }

   805       return e;

   806     }

   807     EdgeIt& next(EdgeIt& e) const {

   808       if (!e.backward) {

   809 	this->graph->next(e.e);

   810 	while(this->graph->valid(e.e) && !enabled(e)) {

   811 	  this->graph->next(e.e); }

   812 	if (!this->graph->valid(e.e)) {

   813 	  e.backward=true;

   814 	  this->graph->first(e.e);

   815 	  while(this->graph->valid(e.e) && !enabled(e)) {

   816 	    this->graph->next(e.e); }

   817 	}

   818       } else {

   819 	this->graph->next(e.e);

   820 	while(this->graph->valid(e.e) && !enabled(e)) {

   821 	  this->graph->next(e.e); }

   822       }

   823       return e;

   824     }

   826     Node tail(Edge e) const {

   827       return ((!e.backward) ? this->graph->tail(e) : this->graph->head(e)); }

   828     Node head(Edge e) const {

   829       return ((!e.backward) ? this->graph->head(e) : this->graph->tail(e)); }

   831     Node aNode(OutEdgeIt e) const {

   832       return ((!e.backward) ? this->graph->aNode(e.out) :

   833 	      this->graph->aNode(e.in)); }

   834     Node bNode(OutEdgeIt e) const {

   835       return ((!e.backward) ? this->graph->bNode(e.out) :

   836 	      this->graph->bNode(e.in)); }

   838     Node aNode(InEdgeIt e) const {

   839       return ((!e.backward) ? this->graph->aNode(e.in) :

   840 	      this->graph->aNode(e.out)); }

   841     Node bNode(InEdgeIt e) const {

   842       return ((!e.backward) ? this->graph->bNode(e.in) :

   843 	      this->graph->bNode(e.out)); }

   845     /// Gives back the opposite edge.

   846     Edge opposite(const Edge& e) const {

   847       Edge f=e;

   848       f.backward=!f.backward;

   849       return f;

   850     }

   852 //    int nodeNum() const { return graph->nodeNum(); }

   853     //FIXME

   854     void edgeNum() const { }

   855     //int edgeNum() const { return graph->edgeNum(); }

   858 //    int id(Node v) const { return graph->id(v); }

   860     bool valid(Node n) const { return GraphWrapper<Graph>::valid(n); }

   861     bool valid(Edge e) const {

   862       return this->graph->valid(e);

   863 	//return e.forward ? graph->valid(e.out) : graph->valid(e.in);

   864     }

   866     bool forward(const Edge& e) const { return !e.backward; }

   867     bool backward(const Edge& e) const { return e.backward; }

   869 //     void augment(const Edge& e, Number a) const {

   870 //       if (!e.backward)

   871 // // 	flow->set(e.out, flow->get(e.out)+a);

   872 // 	flow->set(e, (*flow)[e]+a);

   873 //       else

   874 // // 	flow->set(e.in, flow->get(e.in)-a);

   875 // 	flow->set(e, (*flow)[e]-a);

   876 //     }

   878     bool enabled(const Edge& e) const {

   879       if (!e.backward)

   880 //	return (capacity->get(e.out)-flow->get(e.out));

   881 	//return ((*capacity)[e]-(*flow)[e]);

   882 	return true;

   883       else

   884 //	return (flow->get(e.in));

   885 	//return ((*flow)[e]);

   886 	return true;

   887     }

   889 //     Number enabled(typename Graph::OutEdgeIt out) const {

   890 // //      return (capacity->get(out)-flow->get(out));

   891 //       return ((*capacity)[out]-(*flow)[out]);

   892 //     }

   894 //     Number enabled(typename Graph::InEdgeIt in) const {

   895 // //      return (flow->get(in));

   896 //       return ((*flow)[in]);

   897 //     }

   899     template <typename T>

   900     class EdgeMap {

   901       typename Graph::template EdgeMap<T> forward_map, backward_map;

   902     public:

   903       typedef T ValueType;

   904       typedef Edge KeyType;

   905       EdgeMap(const BidirGraphWrapper<Graph>& _G) : forward_map(*(_G.graph)), backward_map(*(_G.graph)) { }

   906       EdgeMap(const BidirGraphWrapper<Graph>& _G, T a) : forward_map(*(_G.graph), a), backward_map(*(_G.graph), a) { }

   907       void set(Edge e, T a) {

   908 	if (!e.backward)

   909 	  forward_map.set(e/*.out*/, a);

   910 	else

   911 	  backward_map.set(e/*.in*/, a);

   912       }

   913       T operator[](Edge e) const {

   914 	if (!e.backward)

   915 	  return forward_map[e/*.out*/];

   916 	else

   917 	  return backward_map[e/*.in*/];

   918       }

   919 //       T get(Edge e) const {

   920 // 	if (e.out_or_in)

   921 // 	  return forward_map.get(e.out);

   922 // 	else

   923 // 	  return backward_map.get(e.in);

   924 //       }

   925     };

   926   };

   928   /// \brief A bidirected graph template.

   929   ///

   930   /// A bidirected graph template.

   931   /// Such a bidirected graph stores each pair of oppositely directed edges

   932   /// ones in the memory, i.e. a directed graph of type

   933   /// \c Graph is used for that.

   934   /// As the oppositely directed edges are logically different ones

   935   /// the maps are able to attach different values for them.

   936   /// \ingroup graphs

   937   template<typename Graph>

   938   class BidirGraph : public BidirGraphWrapper<Graph> {

   939     typedef UndirGraphWrapper<Graph> Parent;

   940   protected:

   941     Graph gr;

   942   public:

   943     BidirGraph() : BidirGraphWrapper<Graph>() {

   944       Parent::setGraph(gr);

   945     }

   946   };

   949   /// A wrapper for composing the residual graph for directed flow and circulation problems.

   951   /// A wrapper for composing the residual graph for directed flow and circulation problems.

   952   template<typename Graph, typename Number,

   953 	   typename CapacityMap, typename FlowMap>

   954   class ResGraphWrapper : public GraphWrapper<Graph> {

   955   protected:

   956     const CapacityMap* capacity;

   957     FlowMap* flow;

   959     ResGraphWrapper() : GraphWrapper<Graph>(0),

   960 			capacity(0), flow(0) { }

   961     void setCapacityMap(const CapacityMap& _capacity) {

   962       capacity=&_capacity;

   963     }

   964     void setFlowMap(FlowMap& _flow) {

   965       flow=&_flow;

   966     }

   968   public:

   970     ResGraphWrapper(Graph& _graph, const CapacityMap& _capacity,

   971 		    FlowMap& _flow) :

   972       GraphWrapper<Graph>(_graph), capacity(&_capacity), flow(&_flow) { }

   974     class Edge;

   975     class OutEdgeIt;

   976     friend class Edge;

   977     friend class OutEdgeIt;

   979     typedef typename GraphWrapper<Graph>::Node Node;

   980     typedef typename GraphWrapper<Graph>::NodeIt NodeIt;

   981     class Edge : public Graph::Edge {

   982       friend class ResGraphWrapper<Graph, Number, CapacityMap, FlowMap>;

   983     protected:

   984       bool backward; //true, iff backward

   985 //      typename Graph::Edge e;

   986     public:

   987       Edge() { }

   988       Edge(const typename Graph::Edge& _e, bool _backward) :

   989 	Graph::Edge(_e), backward(_backward) { }

   990       Edge(const Invalid& i) : Graph::Edge(i), backward(true) { }

   991 //the unique invalid iterator

   992       friend bool operator==(const Edge& u, const Edge& v) {

   993 	return (v.backward==u.backward &&

   994 		static_cast<typename Graph::Edge>(u)==

   995 		static_cast<typename Graph::Edge>(v));

   996       }

   997       friend bool operator!=(const Edge& u, const Edge& v) {

   998 	return (v.backward!=u.backward ||

   999 		static_cast<typename Graph::Edge>(u)!=

  1000 		static_cast<typename Graph::Edge>(v));

  1001       }

  1002     };

  1004     class OutEdgeIt {

  1005       friend class ResGraphWrapper<Graph, Number, CapacityMap, FlowMap>;

  1006     protected:

  1007       typename Graph::OutEdgeIt out;

  1008       typename Graph::InEdgeIt in;

  1009       bool backward;

  1010     public:

  1011       OutEdgeIt() { }

  1012       //FIXME

  1013 //      OutEdgeIt(const Edge& e) : Edge(e) { }

  1014       OutEdgeIt(const Invalid& i) : out(i), in(i), backward(true) { }

  1015 //the unique invalid iterator

  1016       OutEdgeIt(const ResGraphWrapper<Graph, Number, CapacityMap, FlowMap>& _G, Node v) {

  1017 	backward=false;

  1018 	_G.graph->first(out, v);

  1019 	while( _G.graph->valid(out) && !(_G.resCap(*this)>0) ) { _G.graph->next(out); }

  1020 	if (!_G.graph->valid(out)) {

  1021 	  backward=true;

  1022 	  _G.graph->first(in, v);

  1023 	  while( _G.graph->valid(in) && !(_G.resCap(*this)>0) ) { _G.graph->next(in); }

  1024 	}

  1025       }

  1026       operator Edge() const {

  1027 //	Edge e;

  1028 //	e.forward=this->forward;

  1029 //	if (this->forward) e=out; else e=in;

  1030 //	return e;

  1031 	if (this->backward)

  1032 	  return Edge(in, this->backward);

  1033 	else

  1034 	  return Edge(out, this->backward);

  1035       }

  1036     };

  1038     class InEdgeIt {

  1039       friend class ResGraphWrapper<Graph, Number, CapacityMap, FlowMap>;

  1040     protected:

  1041       typename Graph::OutEdgeIt out;

  1042       typename Graph::InEdgeIt in;

  1043       bool backward;

  1044     public:

  1045       InEdgeIt() { }

  1046       //FIXME

  1047 //      OutEdgeIt(const Edge& e) : Edge(e) { }

  1048       InEdgeIt(const Invalid& i) : out(i), in(i), backward(true) { }

  1049 //the unique invalid iterator

  1050       InEdgeIt(const ResGraphWrapper<Graph, Number, CapacityMap, FlowMap>& _G, Node v) {

  1051 	backward=false;

  1052 	_G.graph->first(in, v);

  1053 	while( _G.graph->valid(in) && !(_G.resCap(*this)>0) ) { _G.graph->next(in); }

  1054 	if (!_G.graph->valid(in)) {

  1055 	  backward=true;

  1056 	  _G.graph->first(out, v);

  1057 	  while( _G.graph->valid(out) && !(_G.resCap(*this)>0) ) { _G.graph->next(out); }

  1058 	}

  1059       }

  1060       operator Edge() const {

  1061 //	Edge e;

  1062 //	e.forward=this->forward;

  1063 //	if (this->forward) e=out; else e=in;

  1064 //	return e;

  1065 	if (this->backward)

  1066 	  return Edge(out, this->backward);

  1067 	else

  1068 	  return Edge(in, this->backward);

  1069       }

  1070     };

  1072     class EdgeIt {

  1073       friend class ResGraphWrapper<Graph, Number, CapacityMap, FlowMap>;

  1074     protected:

  1075       typename Graph::EdgeIt e;

  1076       bool backward;

  1077     public:

  1078       EdgeIt() { }

  1079       EdgeIt(const Invalid& i) : e(i), backward(true) { }

  1080       EdgeIt(const ResGraphWrapper<Graph, Number, CapacityMap, FlowMap>& _G) {

  1081 	backward=false;

  1082 	_G.graph->first(e);

  1083 	while (_G.graph->valid(e) && !(_G.resCap(*this)>0)) _G.graph->next(e);

  1084 	if (!_G.graph->valid(e)) {

  1085 	  backward=true;

  1086 	  _G.graph->first(e);

  1087 	  while (_G.graph->valid(e) && !(_G.resCap(*this)>0)) _G.graph->next(e);

  1088 	}

  1089       }

  1090       operator Edge() const {

  1091 	return Edge(e, this->backward);

  1092       }

  1093     };

  1095     using GraphWrapper<Graph>::first;

  1096 //     NodeIt& first(NodeIt& i) const {

  1097 //       i=NodeIt(*this); return i;

  1098 //     }

  1099     OutEdgeIt& first(OutEdgeIt& i, const Node& p) const {

  1100       i=OutEdgeIt(*this, p); return i;

  1101     }

  1102 //    FIXME not tested

  1103     InEdgeIt& first(InEdgeIt& i, const Node& p) const {

  1104       i=InEdgeIt(*this, p); return i;

  1105     }

  1106     EdgeIt& first(EdgeIt& i) const {

  1107       i=EdgeIt(*this); return i;

  1108     }

  1110     using GraphWrapper<Graph>::next;

  1111 //    NodeIt& next(NodeIt& n) const { GraphWrapper<Graph>::next(n); return n; }

  1112     OutEdgeIt& next(OutEdgeIt& e) const {

  1113       if (!e.backward) {

  1114 	Node v=this->graph->aNode(e.out);

  1115 	this->graph->next(e.out);

  1116 	while( this->graph->valid(e.out) && !(resCap(e)>0) ) {

  1117 	  this->graph->next(e.out); }

  1118 	if (!this->graph->valid(e.out)) {

  1119 	  e.backward=true;

  1120 	  this->graph->first(e.in, v);

  1121 	  while( this->graph->valid(e.in) && !(resCap(e)>0) ) {

  1122 	    this->graph->next(e.in); }

  1123 	}

  1124       } else {

  1125 	this->graph->next(e.in);

  1126 	while( this->graph->valid(e.in) && !(resCap(e)>0) ) {

  1127 	  this->graph->next(e.in); }

  1128       }

  1129       return e;

  1130     }

  1131 //     FIXME Not tested

  1132     InEdgeIt& next(InEdgeIt& e) const {

  1133       if (!e.backward) {

  1134 	Node v=this->graph->aNode(e.in);

  1135 	this->graph->next(e.in);

  1136 	while( this->graph->valid(e.in) && !(resCap(e)>0) ) {

  1137 	  this->graph->next(e.in); }

  1138 	if (!this->graph->valid(e.in)) {

  1139 	  e.backward=true;

  1140 	  this->graph->first(e.out, v);

  1141 	  while( this->graph->valid(e.out) && !(resCap(e)>0) ) {

  1142 	    this->graph->next(e.out); }

  1143 	}

  1144       } else {

  1145 	this->graph->next(e.out);

  1146 	while( this->graph->valid(e.out) && !(resCap(e)>0) ) {

  1147 	  this->graph->next(e.out); }

  1148       }

  1149       return e;

  1150     }

  1151     EdgeIt& next(EdgeIt& e) const {

  1152       if (!e.backward) {

  1153 	this->graph->next(e.e);

  1154 	while( this->graph->valid(e.e) && !(resCap(e)>0) ) {

  1155 	  this->graph->next(e.e); }

  1156 	if (!this->graph->valid(e.e)) {

  1157 	  e.backward=true;

  1158 	  this->graph->first(e.e);

  1159 	  while( this->graph->valid(e.e) && !(resCap(e)>0) ) {

  1160 	    this->graph->next(e.e); }

  1161 	}

  1162       } else {

  1163 	this->graph->next(e.e);

  1164 	while( this->graph->valid(e.e) && !(resCap(e)>0) ) {

  1165 	  this->graph->next(e.e); }

  1166       }

  1167       return e;

  1168     }

  1170     Node tail(Edge e) const {

  1171       return ((!e.backward) ? this->graph->tail(e) : this->graph->head(e)); }

  1172     Node head(Edge e) const {

  1173       return ((!e.backward) ? this->graph->head(e) : this->graph->tail(e)); }

  1175     Node aNode(OutEdgeIt e) const {

  1176       return ((!e.backward) ? this->graph->aNode(e.out) :

  1177 	      this->graph->aNode(e.in)); }

  1178     Node bNode(OutEdgeIt e) const {

  1179       return ((!e.backward) ? this->graph->bNode(e.out) :

  1180 	      this->graph->bNode(e.in)); }

  1182     Node aNode(InEdgeIt e) const {

  1183       return ((!e.backward) ? this->graph->aNode(e.in) :

  1184 	      this->graph->aNode(e.out)); }

  1185     Node bNode(InEdgeIt e) const {

  1186       return ((!e.backward) ? this->graph->bNode(e.in) :

  1187 	      this->graph->bNode(e.out)); }

  1189 //    int nodeNum() const { return graph->nodeNum(); }

  1190     //FIXME

  1191     void edgeNum() const { }

  1192     //int edgeNum() const { return graph->edgeNum(); }

  1195 //    int id(Node v) const { return graph->id(v); }

  1197     bool valid(Node n) const { return GraphWrapper<Graph>::valid(n); }

  1198     bool valid(Edge e) const {

  1199       return this->graph->valid(e);

  1200 	//return e.forward ? graph->valid(e.out) : graph->valid(e.in);

  1201     }

  1203     bool forward(const Edge& e) const { return !e.backward; }

  1204     bool backward(const Edge& e) const { return e.backward; }

  1206     void augment(const Edge& e, Number a) const {

  1207       if (!e.backward)

  1208 // 	flow->set(e.out, flow->get(e.out)+a);

  1209 	flow->set(e, (*flow)[e]+a);

  1210       else

  1211 // 	flow->set(e.in, flow->get(e.in)-a);

  1212 	flow->set(e, (*flow)[e]-a);

  1213     }

  1215     Number resCap(const Edge& e) const {

  1216       if (!e.backward)

  1217 //	return (capacity->get(e.out)-flow->get(e.out));

  1218 	return ((*capacity)[e]-(*flow)[e]);

  1219       else

  1220 //	return (flow->get(e.in));

  1221 	return ((*flow)[e]);

  1222     }

  1224 //     Number resCap(typename Graph::OutEdgeIt out) const {

  1225 // //      return (capacity->get(out)-flow->get(out));

  1226 //       return ((*capacity)[out]-(*flow)[out]);

  1227 //     }

  1229 //     Number resCap(typename Graph::InEdgeIt in) const {

  1230 // //      return (flow->get(in));

  1231 //       return ((*flow)[in]);

  1232 //     }

  1234     template <typename T>

  1235     class EdgeMap {

  1236       typename Graph::template EdgeMap<T> forward_map, backward_map;

  1237     public:

  1238       typedef T ValueType;

  1239       typedef Edge KeyType;

  1240       EdgeMap(const ResGraphWrapper<Graph, Number, CapacityMap, FlowMap>& _G) : forward_map(*(_G.graph)), backward_map(*(_G.graph)) { }

  1241       EdgeMap(const ResGraphWrapper<Graph, Number, CapacityMap, FlowMap>& _G, T a) : forward_map(*(_G.graph), a), backward_map(*(_G.graph), a) { }

  1242       void set(Edge e, T a) {

  1243 	if (!e.backward)

  1244 	  forward_map.set(e/*.out*/, a);

  1245 	else

  1246 	  backward_map.set(e/*.in*/, a);

  1247       }

  1248       T operator[](Edge e) const {

  1249 	if (!e.backward)

  1250 	  return forward_map[e/*.out*/];

  1251 	else

  1252 	  return backward_map[e/*.in*/];

  1253       }

  1254 //       T get(Edge e) const {

  1255 // 	if (e.out_or_in)

  1256 // 	  return forward_map.get(e.out);

  1257 // 	else

  1258 // 	  return backward_map.get(e.in);

  1259 //       }

  1260     };

  1261   };

  1265   /// For blocking flows.

  1267   /// This graph wrapper is used for Dinits blocking flow computations.

  1268   /// For each node, an out-edge is stored which is used when the

  1269   /// \code

  1270   /// OutEdgeIt& first(OutEdgeIt&, const Node&)

  1271   /// \endcode

  1272   /// is called.

  1273   ///

  1274   ///\author Marton Makai

  1275   template<typename Graph, typename FirstOutEdgesMap>

  1276   class ErasingFirstGraphWrapper : public GraphWrapper<Graph> {

  1277   protected:

  1278     FirstOutEdgesMap* first_out_edges;

  1279   public:

  1280     ErasingFirstGraphWrapper(Graph& _graph,

  1281 			     FirstOutEdgesMap& _first_out_edges) :

  1282       GraphWrapper<Graph>(_graph), first_out_edges(&_first_out_edges) { }

  1284     typedef typename GraphWrapper<Graph>::Node Node;

  1285 //     class NodeIt {

  1286 //       friend class GraphWrapper<Graph>;

  1287 //       friend class ErasingFirstGraphWrapper<Graph, FirstOutEdgesMap>;

  1288 //       typename Graph::NodeIt n;

  1289 //      public:

  1290 //       NodeIt() { }

  1291 //       NodeIt(const typename Graph::NodeIt& _n) : n(_n) { }

  1292 //       NodeIt(const Invalid& i) : n(i) { }

  1293 //       NodeIt(const ErasingFirstGraphWrapper<Graph, FirstOutEdgesMap>& _G) :

  1294 // 	n(*(_G.graph)) { }

  1295 //       operator Node() const { return Node(typename Graph::Node(n)); }

  1296 //     };

  1297     typedef typename GraphWrapper<Graph>::Edge Edge;

  1298     class OutEdgeIt {

  1299       friend class GraphWrapper<Graph>;

  1300       friend class ErasingFirstGraphWrapper<Graph, FirstOutEdgesMap>;

  1301 //      typedef typename Graph::OutEdgeIt GraphOutEdgeIt;

  1302       typename Graph::OutEdgeIt e;

  1303     public:

  1304       OutEdgeIt() { }

  1305       OutEdgeIt(const typename Graph::OutEdgeIt& _e) : e(_e) { }

  1306       OutEdgeIt(const Invalid& i) : e(i) { }

  1307       OutEdgeIt(const ErasingFirstGraphWrapper<Graph, FirstOutEdgesMap>& _G,

  1308 		const Node& _n) :

  1309 	e((*_G.first_out_edges)[_n]) { }

  1310       operator Edge() const { return Edge(typename Graph::Edge(e)); }

  1311     };

  1312     class InEdgeIt {

  1313       friend class GraphWrapper<Graph>;

  1314       friend class ErasingFirstGraphWrapper<Graph, FirstOutEdgesMap>;

  1315 //      typedef typename Graph::InEdgeIt GraphInEdgeIt;

  1316       typename Graph::InEdgeIt e;

  1317     public:

  1318       InEdgeIt() { }

  1319       InEdgeIt(const typename Graph::InEdgeIt& _e) : e(_e) { }

  1320       InEdgeIt(const Invalid& i) : e(i) { }

  1321       InEdgeIt(const ErasingFirstGraphWrapper<Graph, FirstOutEdgesMap>& _G,

  1322 	       const Node& _n) :

  1323 	e(*(_G.graph), typename Graph::Node(_n)) { }

  1324       operator Edge() const { return Edge(typename Graph::Edge(e)); }

  1325     };

  1326     //typedef typename Graph::SymEdgeIt SymEdgeIt;

  1327     class EdgeIt {

  1328       friend class GraphWrapper<Graph>;

  1329       friend class ErasingFirstGraphWrapper<Graph, FirstOutEdgesMap>;

  1330 //      typedef typename Graph::EdgeIt GraphEdgeIt;

  1331       typename Graph::EdgeIt e;

  1332     public:

  1333       EdgeIt() { }

  1334       EdgeIt(const typename Graph::EdgeIt& _e) : e(_e) { }

  1335       EdgeIt(const Invalid& i) : e(i) { }

  1336       EdgeIt(const ErasingFirstGraphWrapper<Graph, FirstOutEdgesMap>& _G) :

  1337 	e(*(_G.graph)) { }

  1338       operator Edge() const { return Edge(typename Graph::Edge(e)); }

  1339     };

  1341     using GraphWrapper<Graph>::first;

  1342 //     NodeIt& first(NodeIt& i) const {

  1343 //       i=NodeIt(*this); return i;

  1344 //     }

  1345     OutEdgeIt& first(OutEdgeIt& i, const Node& p) const {

  1346       i=OutEdgeIt(*this, p); return i;

  1347     }

  1348     InEdgeIt& first(InEdgeIt& i, const Node& p) const {

  1349       i=InEdgeIt(*this, p); return i;

  1350     }

  1351     EdgeIt& first(EdgeIt& i) const {

  1352       i=EdgeIt(*this); return i;

  1353     }

  1355     using GraphWrapper<Graph>::next;

  1356 //    NodeIt& next(NodeIt& i) const { graph->next(i.n); return i; }

  1357     OutEdgeIt& next(OutEdgeIt& i) const { this->graph->next(i.e); return i; }

  1358     InEdgeIt& next(InEdgeIt& i) const { this->graph->next(i.e); return i; }

  1359     EdgeIt& next(EdgeIt& i) const { this->graph->next(i.e); return i; }

  1361     Node aNode(const OutEdgeIt& e) const {

  1362       return Node(this->graph->aNode(e.e)); }

  1363     Node aNode(const InEdgeIt& e) const {

  1364       return Node(this->graph->aNode(e.e)); }

  1365     Node bNode(const OutEdgeIt& e) const {

  1366       return Node(this->graph->bNode(e.e)); }

  1367     Node bNode(const InEdgeIt& e) const {

  1368       return Node(this->graph->bNode(e.e)); }

  1370     void erase(const OutEdgeIt& e) const {

  1371       OutEdgeIt f=e;

  1372       this->next(f);

  1373       first_out_edges->set(this->tail(e), f.e);

  1374     }

  1375   };

  1377   ///@}

  1379 } //namespace hugo

  1381 #endif //HUGO_GRAPH_WRAPPER_H

author	marci
	Wed, 12 May 2004 13:55:37 +0000
changeset 624	2e2618612b68
parent 623	cd4296da1643
child 625	28634fadbf9a
permissions	-rw-r--r--