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

     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

    87   template<typename Graph>

    88   class GraphWrapper {

    89   protected:

    90     Graph* graph;

    91     GraphWrapper() : graph(0) { }

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

    94   public:

    95     typedef Graph BaseGraph;

    96     typedef Graph ParentGraph;

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

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

   101 //    typedef typename Graph::Node Node;

   102     class Node : public Graph::Node {

   103       friend class GraphWrapper<Graph>;

   104     public:

   105       Node() { }

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

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

   108     };

   109     class NodeIt {

   110       friend class GraphWrapper<Graph>;

   111       typename Graph::NodeIt n;

   112      public:

   113       NodeIt() { }

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

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

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

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

   118     };

   119 //    typedef typename Graph::Edge Edge;

   120     class Edge : public Graph::Edge {

   121       friend class GraphWrapper<Graph>;

   122     public:

   123       Edge() { }

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

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

   126     };

   127     class OutEdgeIt {

   128       friend class GraphWrapper<Graph>;

   129       typename Graph::OutEdgeIt e;

   130     public:

   131       OutEdgeIt() { }

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

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

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

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

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

   137     };

   138     class InEdgeIt {

   139       friend class GraphWrapper<Graph>;

   140       typename Graph::InEdgeIt e;

   141     public:

   142       InEdgeIt() { }

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

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

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

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

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

   148     };

   149     //typedef typename Graph::SymEdgeIt SymEdgeIt;

   150     class EdgeIt {

   151       friend class GraphWrapper<Graph>;

   152       typename Graph::EdgeIt e;

   153     public:

   154       EdgeIt() { }

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

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

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

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

   159     };

   161     NodeIt& first(NodeIt& i) const {

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

   163     }

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

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

   166     }

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

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

   169     }

   170     EdgeIt& first(EdgeIt& i) const {

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

   172     }

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

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

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

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

   179     Node tail(const Edge& e) const {

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

   181     Node head(const Edge& e) const {

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

   184     bool valid(const Node& n) const {

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

   186     bool valid(const Edge& e) const {

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

   208     public:

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

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

   211     };

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

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

   215     public:

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

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

   218     };

   219   };

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

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

   226   ///

   227   ///\author Marton Makai

   228   template<typename Graph>

   229   class RevGraphWrapper : public GraphWrapper<Graph> {

   230   protected:

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

   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   /// 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>(0),

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

   468   };

   472   /// A wrapper for forgetting the orientation of a graph.

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

   475   /// the orientation of a directed one.

   476   template<typename Graph>

   477   class UndirGraphWrapper : public GraphWrapper<Graph> {

   478   protected:

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

   481   public:

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

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

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

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

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

   489     class OutEdgeIt {

   490       friend class UndirGraphWrapper<Graph>;

   491       bool out_or_in; //true iff out

   492       typename Graph::OutEdgeIt out;

   493       typename Graph::InEdgeIt in;

   494     public:

   495       OutEdgeIt() { }

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

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

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

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

   500       }

   501       operator Edge() const {

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

   503       }

   504     };

   506 //FIXME InEdgeIt

   507     typedef OutEdgeIt InEdgeIt;

   509     using GraphWrapper<Graph>::first;

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

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

   512 //     }

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

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

   515     }

   516 //FIXME

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

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

   519 //     }

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

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

   522 //     }

   524     using GraphWrapper<Graph>::next;

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

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

   527 //       return n;

   528 //     }

   529     OutEdgeIt& next(OutEdgeIt& e) const {

   530       if (e.out_or_in) {

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

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

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

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

   535       } else {

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

   537       }

   538       return e;

   539     }

   540     //FIXME InEdgeIt

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

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

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

   544 //       return e;

   545 //     }

   547     Node aNode(const OutEdgeIt& e) const {

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

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

   550     Node bNode(const OutEdgeIt& e) const {

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

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

   553   };

   557   /// An undirected graph template

   558   template<typename Graph>

   559   class UndirGraph : public UndirGraphWrapper<Graph> {

   560     typedef UndirGraphWrapper<Graph> Parent;

   561   protected:

   562     Graph gr;

   563   public:

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

   565       Parent::setGraph(gr);

   566     }

   567   };

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

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

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

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

   575   template<typename Graph>

   576   class BidirGraphWrapper : public GraphWrapper<Graph> {

   577   protected:

   578     //const CapacityMap* capacity;

   579     //FlowMap* flow;

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

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

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

   584 //       capacity=&_capacity;

   585 //     }

   586 //     void setFlowMap(FlowMap& _flow) {

   587 //       flow=&_flow;

   588 //     }

   590   public:

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

   593 				     FlowMap& _flow*/) :

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

   596     class Edge;

   597     class OutEdgeIt;

   598     friend class Edge;

   599     friend class OutEdgeIt;

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

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

   603     class Edge : public Graph::Edge {

   604       friend class BidirGraphWrapper<Graph>;

   605     protected:

   606       bool backward; //true, iff backward

   607 //      typename Graph::Edge e;

   608     public:

   609       Edge() { }

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

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

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

   613 //the unique invalid iterator

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

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

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

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

   618       }

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

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

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

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

   623       }

   624     };

   626     class OutEdgeIt {

   627       friend class BidirGraphWrapper<Graph>;

   628     protected:

   629       typename Graph::OutEdgeIt out;

   630       typename Graph::InEdgeIt in;

   631       bool backward;

   632     public:

   633       OutEdgeIt() { }

   634       //FIXME

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

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

   637 //the unique invalid iterator

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

   639 	backward=false;

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

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

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

   643 	  backward=true;

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

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

   646 	}

   647       }

   648       operator Edge() const {

   649 //	Edge e;

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

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

   652 //	return e;

   653 	if (this->backward)

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

   655 	else

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

   657       }

   658     };

   660     class InEdgeIt {

   661       friend class BidirGraphWrapper<Graph>;

   662     protected:

   663       typename Graph::OutEdgeIt out;

   664       typename Graph::InEdgeIt in;

   665       bool backward;

   666     public:

   667       InEdgeIt() { }

   668       //FIXME

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

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

   671 //the unique invalid iterator

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

   673 	backward=false;

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

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

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

   677 	  backward=true;

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

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

   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(out, this->backward);

   689 	else

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

   691       }

   692     };

   694     class EdgeIt {

   695       friend class BidirGraphWrapper<Graph>;

   696     protected:

   697       typename Graph::EdgeIt e;

   698       bool backward;

   699     public:

   700       EdgeIt() { }

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

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

   703 	backward=false;

   704 	_G.graph->first(e);

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

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

   707 	  backward=true;

   708 	  _G.graph->first(e);

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

   710 	}

   711       }

   712       operator Edge() const {

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

   714       }

   715     };

   717     using GraphWrapper<Graph>::first;

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

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

   720 //     }

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

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

   723     }

   724 //    FIXME not tested

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

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

   727     }

   728     EdgeIt& first(EdgeIt& i) const {

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

   730     }

   732     using GraphWrapper<Graph>::next;

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

   734     OutEdgeIt& next(OutEdgeIt& e) const {

   735       if (!e.backward) {

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

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

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

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

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

   741 	  e.backward=true;

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

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

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

   745 	}

   746       } else {

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

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

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

   750       }

   751       return e;

   752     }

   753 //     FIXME Not tested

   754     InEdgeIt& next(InEdgeIt& e) const {

   755       if (!e.backward) {

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

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

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

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

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

   761 	  e.backward=true;

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

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

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

   765 	}

   766       } else {

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

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

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

   770       }

   771       return e;

   772     }

   773     EdgeIt& next(EdgeIt& e) const {

   774       if (!e.backward) {

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

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

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

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

   779 	  e.backward=true;

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

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

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

   783 	}

   784       } else {

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

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

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

   788       }

   789       return e;

   790     }

   792     Node tail(Edge e) const {

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

   794     Node head(Edge e) const {

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

   797     Node aNode(OutEdgeIt e) const {

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

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

   800     Node bNode(OutEdgeIt e) const {

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

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

   804     Node aNode(InEdgeIt e) const {

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

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

   807     Node bNode(InEdgeIt e) const {

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

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

   811     /// Gives back the opposite edge.

   812     Edge opposite(const Edge& e) const {

   813       Edge f=e;

   814       f.backward=!f.backward;

   815       return f;

   816     }

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

   819     //FIXME

   820     void edgeNum() const { }

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

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

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

   827     bool valid(Edge e) const {

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

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

   830     }

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

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

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

   836 //       if (!e.backward)

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

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

   839 //       else

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

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

   842 //     }

   844     bool enabled(const Edge& e) const {

   845       if (!e.backward)

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

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

   848 	return true;

   849       else

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

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

   852 	return true;

   853     }

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

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

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

   858 //     }

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

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

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

   863 //     }

   865     template <typename T>

   866     class EdgeMap {

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

   868     public:

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

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

   871       void set(Edge e, T a) {

   872 	if (!e.backward)

   873 	  forward_map.set(e.out, a);

   874 	else

   875 	  backward_map.set(e.in, a);

   876       }

   877       T operator[](Edge e) const {

   878 	if (!e.backward)

   879 	  return forward_map[e.out];

   880 	else

   881 	  return backward_map[e.in];

   882       }

   883 //       T get(Edge e) const {

   884 // 	if (e.out_or_in)

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

   886 // 	else

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

   888 //       }

   889     };

   890   };

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

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

   897   template<typename Graph, typename Number,

   898 	   typename CapacityMap, typename FlowMap>

   899   class ResGraphWrapper : public GraphWrapper<Graph> {

   900   protected:

   901     const CapacityMap* capacity;

   902     FlowMap* flow;

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

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

   906     void setCapacityMap(const CapacityMap& _capacity) {

   907       capacity=&_capacity;

   908     }

   909     void setFlowMap(FlowMap& _flow) {

   910       flow=&_flow;

   911     }

   913   public:

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

   916 		    FlowMap& _flow) :

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

   919     class Edge;

   920     class OutEdgeIt;

   921     friend class Edge;

   922     friend class OutEdgeIt;

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

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

   926     class Edge : public Graph::Edge {

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

   928     protected:

   929       bool backward; //true, iff backward

   930 //      typename Graph::Edge e;

   931     public:

   932       Edge() { }

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

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

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

   936 //the unique invalid iterator

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

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

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

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

   941       }

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

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

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

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

   946       }

   947     };

   949     class OutEdgeIt {

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

   951     protected:

   952       typename Graph::OutEdgeIt out;

   953       typename Graph::InEdgeIt in;

   954       bool backward;

   955     public:

   956       OutEdgeIt() { }

   957       //FIXME

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

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

   960 //the unique invalid iterator

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

   962 	backward=false;

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

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

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

   966 	  backward=true;

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

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

   969 	}

   970       }

   971       operator Edge() const {

   972 //	Edge e;

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

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

   975 //	return e;

   976 	if (this->backward)

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

   978 	else

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

   980       }

   981     };

   983     class InEdgeIt {

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

   985     protected:

   986       typename Graph::OutEdgeIt out;

   987       typename Graph::InEdgeIt in;

   988       bool backward;

   989     public:

   990       InEdgeIt() { }

   991       //FIXME

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

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

   994 //the unique invalid iterator

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

   996 	backward=false;

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

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

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

  1000 	  backward=true;

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

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

  1003 	}

  1004       }

  1005       operator Edge() const {

  1006 //	Edge e;

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

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

  1009 //	return e;

  1010 	if (this->backward)

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

  1012 	else

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

  1014       }

  1015     };

  1017     class EdgeIt {

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

  1019     protected:

  1020       typename Graph::EdgeIt e;

  1021       bool backward;

  1022     public:

  1023       EdgeIt() { }

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

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

  1026 	backward=false;

  1027 	_G.graph->first(e);

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

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

  1030 	  backward=true;

  1031 	  _G.graph->first(e);

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

  1033 	}

  1034       }

  1035       operator Edge() const {

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

  1037       }

  1038     };

  1040     using GraphWrapper<Graph>::first;

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

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

  1043 //     }

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

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

  1046     }

  1047 //    FIXME not tested

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

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

  1050     }

  1051     EdgeIt& first(EdgeIt& i) const {

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

  1053     }

  1055     using GraphWrapper<Graph>::next;

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

  1057     OutEdgeIt& next(OutEdgeIt& e) const {

  1058       if (!e.backward) {

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

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

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

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

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

  1064 	  e.backward=true;

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

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

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

  1068 	}

  1069       } else {

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

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

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

  1073       }

  1074       return e;

  1075     }

  1076 //     FIXME Not tested

  1077     InEdgeIt& next(InEdgeIt& e) const {

  1078       if (!e.backward) {

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

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

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

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

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

  1084 	  e.backward=true;

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

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

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

  1088 	}

  1089       } else {

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

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

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

  1093       }

  1094       return e;

  1095     }

  1096     EdgeIt& next(EdgeIt& e) const {

  1097       if (!e.backward) {

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

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

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

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

  1102 	  e.backward=true;

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

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

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

  1106 	}

  1107       } else {

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

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

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

  1111       }

  1112       return e;

  1113     }

  1115     Node tail(Edge e) const {

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

  1117     Node head(Edge e) const {

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

  1120     Node aNode(OutEdgeIt e) const {

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

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

  1123     Node bNode(OutEdgeIt e) const {

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

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

  1127     Node aNode(InEdgeIt e) const {

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

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

  1130     Node bNode(InEdgeIt e) const {

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

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

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

  1135     //FIXME

  1136     void edgeNum() const { }

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

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

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

  1143     bool valid(Edge e) const {

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

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

  1146     }

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

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

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

  1152       if (!e.backward)

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

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

  1155       else

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

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

  1158     }

  1160     Number resCap(const Edge& e) const {

  1161       if (!e.backward)

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

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

  1164       else

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

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

  1167     }

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

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

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

  1172 //     }

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

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

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

  1177 //     }

  1179     template <typename T>

  1180     class EdgeMap {

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

  1182     public:

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

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

  1185       void set(Edge e, T a) {

  1186 	if (!e.backward)

  1187 	  forward_map.set(e.out, a);

  1188 	else

  1189 	  backward_map.set(e.in, a);

  1190       }

  1191       T operator[](Edge e) const {

  1192 	if (!e.backward)

  1193 	  return forward_map[e.out];

  1194 	else

  1195 	  return backward_map[e.in];

  1196       }

  1197 //       T get(Edge e) const {

  1198 // 	if (e.out_or_in)

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

  1200 // 	else

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

  1202 //       }

  1203     };

  1204   };

  1208   /// ErasingFirstGraphWrapper for blocking flows.

  1210   /// ErasingFirstGraphWrapper for blocking flows.

  1211   ///

  1212   ///\author Marton Makai

  1213   template<typename Graph, typename FirstOutEdgesMap>

  1214   class ErasingFirstGraphWrapper : public GraphWrapper<Graph> {

  1215   protected:

  1216     FirstOutEdgesMap* first_out_edges;

  1217   public:

  1218     ErasingFirstGraphWrapper(Graph& _graph,

  1219 			     FirstOutEdgesMap& _first_out_edges) :

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

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

  1223 //     class NodeIt {

  1224 //       friend class GraphWrapper<Graph>;

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

  1226 //       typename Graph::NodeIt n;

  1227 //      public:

  1228 //       NodeIt() { }

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

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

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

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

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

  1234 //     };

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

  1236     class OutEdgeIt {

  1237       friend class GraphWrapper<Graph>;

  1238       friend class ErasingFirstGraphWrapper<Graph, FirstOutEdgesMap>;

  1239 //      typedef typename Graph::OutEdgeIt GraphOutEdgeIt;

  1240       typename Graph::OutEdgeIt e;

  1241     public:

  1242       OutEdgeIt() { }

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

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

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

  1246 		const Node& _n) :

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

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

  1249     };

  1250     class InEdgeIt {

  1251       friend class GraphWrapper<Graph>;

  1252       friend class ErasingFirstGraphWrapper<Graph, FirstOutEdgesMap>;

  1253 //      typedef typename Graph::InEdgeIt GraphInEdgeIt;

  1254       typename Graph::InEdgeIt e;

  1255     public:

  1256       InEdgeIt() { }

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

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

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

  1260 	       const Node& _n) :

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

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

  1263     };

  1264     //typedef typename Graph::SymEdgeIt SymEdgeIt;

  1265     class EdgeIt {

  1266       friend class GraphWrapper<Graph>;

  1267       friend class ErasingFirstGraphWrapper<Graph, FirstOutEdgesMap>;

  1268 //      typedef typename Graph::EdgeIt GraphEdgeIt;

  1269       typename Graph::EdgeIt e;

  1270     public:

  1271       EdgeIt() { }

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

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

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

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

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

  1277     };

  1279     using GraphWrapper<Graph>::first;

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

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

  1282 //     }

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

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

  1285     }

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

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

  1288     }

  1289     EdgeIt& first(EdgeIt& i) const {

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

  1291     }

  1293     using GraphWrapper<Graph>::next;

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

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

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

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

  1299     Node aNode(const OutEdgeIt& e) const {

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

  1301     Node aNode(const InEdgeIt& e) const {

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

  1303     Node bNode(const OutEdgeIt& e) const {

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

  1305     Node bNode(const InEdgeIt& e) const {

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

  1308     void erase(const OutEdgeIt& e) const {

  1309       OutEdgeIt f=e;

  1310       this->next(f);

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

  1312     }

  1313   };

  1315   ///@}

  1317 } //namespace hugo

  1320 #endif //HUGO_GRAPH_WRAPPER_H

author	alpar
	Fri, 07 May 2004 16:04:39 +0000
changeset 580	a00f9f1cfab8
parent 572	e9ed28955421
child 589	d89575370bcb
permissions	-rw-r--r--