lemon-1.3: comparison lemon/graph

equal deleted inserted replaced

-:60f17be70719
+:127c20bbac0f
-/* -*- C++ -*-
+/* -*- mode: C++; indent-tabs-mode: nil; -*-
 *
-* This file is a part of LEMON, a generic C++ optimization library
+* This file is a part of LEMON, a generic C++ optimization library.
 *
 * Copyright (C) 2003-2008
 * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
 * (Egervary Research Group on Combinatorial Optimization, EGRES).
 *
 ///Creates convenience typedefs for the digraph types and iterators
 ///This \c \#define creates convenience typedefs for the following types
 ///of \c Digraph: \c Node,  \c NodeIt, \c Arc, \c ArcIt, \c InArcIt,
 ///\c OutArcIt, \c BoolNodeMap, \c IntNodeMap, \c DoubleNodeMap,
 ///\c BoolArcMap, \c IntArcMap, \c DoubleArcMap.
 ///
 ///\note If the graph type is a dependent type, ie. the graph type depend
 ///on a template parameter, then use \c TEMPLATE_DIGRAPH_TYPEDEFS()
 ///macro.
-#define DIGRAPH_TYPEDEFS(Digraph)					\
+#define DIGRAPH_TYPEDEFS(Digraph)                                        \
-typedef Digraph::Node Node;						\
+typedef Digraph::Node Node;                                                \
-typedef Digraph::NodeIt NodeIt;					\
+typedef Digraph::NodeIt NodeIt;                                        \
-typedef Digraph::Arc Arc;						\
+typedef Digraph::Arc Arc;                                                \
-typedef Digraph::ArcIt ArcIt;						\
+typedef Digraph::ArcIt ArcIt;                                                \
-typedef Digraph::InArcIt InArcIt;					\
+typedef Digraph::InArcIt InArcIt;                                        \
-typedef Digraph::OutArcIt OutArcIt;					\
+typedef Digraph::OutArcIt OutArcIt;                                        \
-typedef Digraph::NodeMap<bool> BoolNodeMap;				\
+typedef Digraph::NodeMap<bool> BoolNodeMap;                                \
-typedef Digraph::NodeMap<int> IntNodeMap;				\
+typedef Digraph::NodeMap<int> IntNodeMap;                                \
-typedef Digraph::NodeMap<double> DoubleNodeMap;			\
+typedef Digraph::NodeMap<double> DoubleNodeMap;                        \
-typedef Digraph::ArcMap<bool> BoolArcMap;				\
+typedef Digraph::ArcMap<bool> BoolArcMap;                                \
-typedef Digraph::ArcMap<int> IntArcMap;				\
+typedef Digraph::ArcMap<int> IntArcMap;                                \
 typedef Digraph::ArcMap<double> DoubleArcMap
 ///Creates convenience typedefs for the digraph types and iterators
 ///\see DIGRAPH_TYPEDEFS
 ///
 ///\note Use this macro, if the graph type is a dependent type,
 ///ie. the graph type depend on a template parameter.
-#define TEMPLATE_DIGRAPH_TYPEDEFS(Digraph)				\
+#define TEMPLATE_DIGRAPH_TYPEDEFS(Digraph)                                \
-typedef typename Digraph::Node Node;					\
+typedef typename Digraph::Node Node;                                        \
-typedef typename Digraph::NodeIt NodeIt;				\
+typedef typename Digraph::NodeIt NodeIt;                                \
-typedef typename Digraph::Arc Arc;					\
+typedef typename Digraph::Arc Arc;                                        \
-typedef typename Digraph::ArcIt ArcIt;				\
+typedef typename Digraph::ArcIt ArcIt;                                \
-typedef typename Digraph::InArcIt InArcIt;				\
+typedef typename Digraph::InArcIt InArcIt;                                \
-typedef typename Digraph::OutArcIt OutArcIt;				\
+typedef typename Digraph::OutArcIt OutArcIt;                                \
-typedef typename Digraph::template NodeMap<bool> BoolNodeMap;		\
+typedef typename Digraph::template NodeMap<bool> BoolNodeMap;                \
-typedef typename Digraph::template NodeMap<int> IntNodeMap;		\
+typedef typename Digraph::template NodeMap<int> IntNodeMap;                \
-typedef typename Digraph::template NodeMap<double> DoubleNodeMap;	\
+typedef typename Digraph::template NodeMap<double> DoubleNodeMap;        \
-typedef typename Digraph::template ArcMap<bool> BoolArcMap;		\
+typedef typename Digraph::template ArcMap<bool> BoolArcMap;                \
-typedef typename Digraph::template ArcMap<int> IntArcMap;		\
+typedef typename Digraph::template ArcMap<int> IntArcMap;                \
 typedef typename Digraph::template ArcMap<double> DoubleArcMap
 ///Creates convenience typedefs for the graph types and iterators
 ///This \c \#define creates the same convenience typedefs as defined
 ///by \ref DIGRAPH_TYPEDEFS(Graph) and six more, namely it creates
 ///\c Edge, \c EdgeIt, \c IncEdgeIt, \c BoolEdgeMap, \c IntEdgeMap,
 ///\c DoubleEdgeMap.
 ///
 ///\note If the graph type is a dependent type, ie. the graph type depend
 ///on a template parameter, then use \c TEMPLATE_DIGRAPH_TYPEDEFS()
 ///macro.
-#define GRAPH_TYPEDEFS(Graph)						\
+#define GRAPH_TYPEDEFS(Graph)                                                \
-DIGRAPH_TYPEDEFS(Graph);						\
+DIGRAPH_TYPEDEFS(Graph);                                                \
-typedef Graph::Edge Edge;						\
+typedef Graph::Edge Edge;                                                \
-typedef Graph::EdgeIt EdgeIt;						\
+typedef Graph::EdgeIt EdgeIt;                                                \
-typedef Graph::IncEdgeIt IncEdgeIt;					\
+typedef Graph::IncEdgeIt IncEdgeIt;                                        \
-typedef Graph::EdgeMap<bool> BoolEdgeMap;				\
+typedef Graph::EdgeMap<bool> BoolEdgeMap;                                \
-typedef Graph::EdgeMap<int> IntEdgeMap;				\
+typedef Graph::EdgeMap<int> IntEdgeMap;                                \
 typedef Graph::EdgeMap<double> DoubleEdgeMap
 ///Creates convenience typedefs for the graph types and iterators
 ///\see GRAPH_TYPEDEFS
 ///
 ///\note Use this macro, if the graph type is a dependent type,
 ///ie. the graph type depend on a template parameter.
-#define TEMPLATE_GRAPH_TYPEDEFS(Graph)					\
+#define TEMPLATE_GRAPH_TYPEDEFS(Graph)                                        \
-TEMPLATE_DIGRAPH_TYPEDEFS(Graph);					\
+TEMPLATE_DIGRAPH_TYPEDEFS(Graph);                                        \
-typedef typename Graph::Edge Edge;					\
+typedef typename Graph::Edge Edge;                                        \
-typedef typename Graph::EdgeIt EdgeIt;				\
+typedef typename Graph::EdgeIt EdgeIt;                                \
-typedef typename Graph::IncEdgeIt IncEdgeIt;				\
+typedef typename Graph::IncEdgeIt IncEdgeIt;                                \
-typedef typename Graph::template EdgeMap<bool> BoolEdgeMap;		\
+typedef typename Graph::template EdgeMap<bool> BoolEdgeMap;                \
-typedef typename Graph::template EdgeMap<int> IntEdgeMap;		\
+typedef typename Graph::template EdgeMap<int> IntEdgeMap;                \
 typedef typename Graph::template EdgeMap<double> DoubleEdgeMap
 /// \brief Function to count the items in the graph.
 ///
 /// This function counts the items (nodes, arcs etc) in the graph.
 }
 // Node counting:
 namespace _graph_utils_bits {
 template <typename Graph, typename Enable = void>
 struct CountNodesSelector {
 static int count(const Graph &g) {
 return countItems<Graph, typename Graph::Node>(g);
 }
 };
 template <typename Graph>
 struct CountNodesSelector<
 Graph, typename
 enable_if<typename Graph::NodeNumTag, void>::type>
 {
 static int count(const Graph &g) {
 return g.nodeNum();
 }
 };
 }
 /// \brief Function to count the nodes in the graph.
 ///
 /// This function counts the nodes in the graph.
 /// The complexity of the function is O(n) but for some
 /// graph structures it is specialized to run in O(1).
 ///
 /// If the graph contains a \e nodeNum() member function and a
 /// \e NodeNumTag tag then this function calls directly the member
 /// function to query the cardinality of the node set.
 template <typename Graph>
 inline int countNodes(const Graph& g) {
 return _graph_utils_bits::CountNodesSelector<Graph>::count(g);
 }
 // Arc counting:
 namespace _graph_utils_bits {
 template <typename Graph, typename Enable = void>
 struct CountArcsSelector {
 static int count(const Graph &g) {
 return countItems<Graph, typename Graph::Arc>(g);
 }
 };
 template <typename Graph>
 struct CountArcsSelector<
 Graph,
 typename enable_if<typename Graph::ArcNumTag, void>::type>
 {
 static int count(const Graph &g) {
 return g.arcNum();
 }
 };
 }
 /// \brief Function to count the arcs in the graph.
 ///
 /// This function counts the arcs in the graph.
 /// The complexity of the function is O(e) but for some
 /// graph structures it is specialized to run in O(1).
 ///
 /// If the graph contains a \e arcNum() member function and a
 /// \e EdgeNumTag tag then this function calls directly the member
 /// function to query the cardinality of the arc set.
 template <typename Graph>
 inline int countArcs(const Graph& g) {
 return _graph_utils_bits::CountArcsSelector<Graph>::count(g);
 }
 // Edge counting:
 namespace _graph_utils_bits {
 template <typename Graph, typename Enable = void>
 struct CountEdgesSelector {
 static int count(const Graph &g) {
 return countItems<Graph, typename Graph::Edge>(g);
 }
 };
 template <typename Graph>
 struct CountEdgesSelector<
 Graph,
 typename enable_if<typename Graph::EdgeNumTag, void>::type>
 {
 static int count(const Graph &g) {
 return g.edgeNum();
 }
 };
 }
 /// \brief Function to count the edges in the graph.
 ///
 /// This function counts the edges in the graph.
 /// The complexity of the function is O(m) but for some
 /// graph structures it is specialized to run in O(1).
 ///
 /// If the graph contains a \e edgeNum() member function and a
 /// \e EdgeNumTag tag then this function calls directly the member
 /// function to query the cardinality of the edge set.
 template <typename Graph>
 inline int countEdges(const Graph& g) {
 return _graph_utils_bits::CountEdgesSelector<Graph>::count(g);
 }
 /// \brief Function to count the number of the out-arcs from node \c n.
 ///
 /// This function counts the number of the out-arcs from node \c n
 /// in the graph.
 template <typename Graph>
 inline int countOutArcs(const Graph& _g,  const typename Graph::Node& _n) {
 return countNodeDegree<Graph, typename Graph::OutArcIt>(_g, _n);
 }
 /// \brief Function to count the number of the in-arcs to node \c n.
 ///
 /// This function counts the number of the in-arcs to node \c n
 /// in the graph.
 template <typename Graph>
 inline int countInArcs(const Graph& _g,  const typename Graph::Node& _n) {
 return countNodeDegree<Graph, typename Graph::InArcIt>(_g, _n);
 }
 /// \brief Function to count the number of the inc-edges to node \c n.
 ///
 /// This function counts the number of the inc-edges to node \c n
 /// in the graph.
 template <typename Graph>
 inline int countIncEdges(const Graph& _g,  const typename Graph::Node& _n) {
 return countNodeDegree<Graph, typename Graph::IncEdgeIt>(_g, _n);
 }
 namespace _graph_utils_bits {
 template <typename Graph, typename Enable = void>
 struct FindArcSelector {
 typedef typename Graph::Node Node;
 typedef typename Graph::Arc Arc;
 static Arc find(const Graph &g, Node u, Node v, Arc e) {
 }
 };
 template <typename Graph>
 struct FindArcSelector<
 Graph,
 typename enable_if<typename Graph::FindEdgeTag, void>::type>
 {
 typedef typename Graph::Node Node;
 typedef typename Graph::Arc Arc;
 static Arc find(const Graph &g, Node u, Node v, Arc prev) {
 return g.findArc(u, v, prev);
 }
 };
 }
 /// \brief Finds an arc between two nodes of a graph.
 ///
 /// Finds an arc from node \c u to node \c v in graph \c g.
 ///\sa ArcLookUp
 ///\sa AllArcLookUp
 ///\sa DynArcLookUp
 ///\sa ConArcIt
 template <typename Graph>
 inline typename Graph::Arc
 findArc(const Graph &g, typename Graph::Node u, typename Graph::Node v,
 typename Graph::Arc prev = INVALID) {
 return _graph_utils_bits::FindArcSelector<Graph>::find(g, u, v, prev);
 }
 /// \brief Iterator for iterating on arcs connected the same nodes.
 ///
 /// Iterator for iterating on arcs connected the same nodes. It is
 /// higher level interface for the findArc() function. You can
 /// use it the following way:
 ///\code
 /// for (ConArcIt<Graph> it(g, src, trg); it != INVALID; ++it) {
 ///   ...
 /// }
 ///\endcode
 ///
 ///\sa findArc()
 ///\sa ArcLookUp
 ///\sa AllArcLookUp
 ///\sa DynArcLookUp
 template <typename _Graph>
 Parent::operator=(findArc(_graph, u, v));
 }
 /// \brief Constructor.
 ///
 /// Construct a new ConArcIt which continues the iterating from
 /// the \c e arc.
 ConArcIt(const Graph& g, Arc a) : Parent(a), _graph(g) {}
 /// \brief Increment operator.
 ///
 /// It increments the iterator and gives back the next arc.
 ConArcIt& operator++() {
 Parent::operator=(findArc(_graph, _graph.source(*this),
-				_graph.target(*this), *this));
+_graph.target(*this), *this));
 return *this;
 }
 private:
 const Graph& _graph;
 };
 namespace _graph_utils_bits {
 template <typename Graph, typename Enable = void>
 struct FindEdgeSelector {
 typedef typename Graph::Node Node;
 typedef typename Graph::Edge Edge;
 static Edge find(const Graph &g, Node u, Node v, Edge e) {
 }
 };
 template <typename Graph>
 struct FindEdgeSelector<
 Graph,
 typename enable_if<typename Graph::FindEdgeTag, void>::type>
 {
 typedef typename Graph::Node Node;
 typedef typename Graph::Edge Edge;
 static Edge find(const Graph &g, Node u, Node v, Edge prev) {
 return g.findEdge(u, v, prev);
 }
 };
 }
 /// \brief Finds an edge between two nodes of a graph.
 ///
 /// Finds an edge from node \c u to node \c v in graph \c g.
 /// the next arc from \c u to \c v after \c prev.
 /// \return The found arc or \ref INVALID if there is no such an arc.
 ///
 /// Thus you can iterate through each arc from \c u to \c v as it follows.
 ///\code
 /// for(Edge e = findEdge(g,u,v); e != INVALID;
 ///     e = findEdge(g,u,v,e)) {
 ///   ...
 /// }
 ///\endcode
 ///
 ///\sa ConEdgeIt
 template <typename Graph>
 inline typename Graph::Edge
 findEdge(const Graph &g, typename Graph::Node u, typename Graph::Node v,
 typename Graph::Edge p = INVALID) {
 return _graph_utils_bits::FindEdgeSelector<Graph>::find(g, u, v, p);
 }
 /// \brief Iterator for iterating on edges connected the same nodes.
 ///
 /// Iterator for iterating on edges connected the same nodes. It is
 /// higher level interface for the findEdge() function. You can
 /// use it the following way:
 ///\code
 /// for (ConEdgeIt<Graph> it(g, src, trg); it != INVALID; ++it) {
 ///   ...
 Parent::operator=(findEdge(_graph, u, v));
 }
 /// \brief Constructor.
 ///
 /// Construct a new ConEdgeIt which continues the iterating from
 /// the \c e edge.
 ConEdgeIt(const Graph& g, Edge e) : Parent(e), _graph(g) {}
 /// \brief Increment operator.
 ///
 /// It increments the iterator and gives back the next edge.
 ConEdgeIt& operator++() {
 Parent::operator=(findEdge(_graph, _graph.u(*this),
-				 _graph.v(*this), *this));
+_graph.v(*this), *this));
 return *this;
 }
 private:
 const Graph& _graph;
 };
 template <typename Digraph, typename Item, typename RefMap>
 class MapCopyBase {
 public:
 virtual void copy(const Digraph& from, const RefMap& refMap) = 0;
 virtual ~MapCopyBase() {}
 };
 template <typename Digraph, typename Item, typename RefMap,
 typename ToMap, typename FromMap>
 class MapCopy : public MapCopyBase<Digraph, Item, RefMap> {
 public:
 MapCopy(ToMap& tmap, const FromMap& map)
 : _tmap(tmap), _map(map) {}
 virtual void copy(const Digraph& digraph, const RefMap& refMap) {
 typedef typename ItemSetTraits<Digraph, Item>::ItemIt ItemIt;
 for (ItemIt it(digraph); it != INVALID; ++it) {
 _tmap.set(refMap[it], _map[it]);
 }
 template <typename Digraph, typename Item, typename RefMap, typename It>
 class ItemCopy : public MapCopyBase<Digraph, Item, RefMap> {
 public:
 ItemCopy(It& it, const Item& item) : _it(it), _item(item) {}
 virtual void copy(const Digraph&, const RefMap& refMap) {
 _it = refMap[_item];
 }
 private:
 template <typename Digraph, typename Item, typename RefMap, typename Ref>
 class RefCopy : public MapCopyBase<Digraph, Item, RefMap> {
 public:
 RefCopy(Ref& map) : _map(map) {}
 virtual void copy(const Digraph& digraph, const RefMap& refMap) {
 typedef typename ItemSetTraits<Digraph, Item>::ItemIt ItemIt;
 for (ItemIt it(digraph); it != INVALID; ++it) {
 _map.set(it, refMap[it]);
 }
 private:
 Ref& _map;
 };
 template <typename Digraph, typename Item, typename RefMap,
 typename CrossRef>
 class CrossRefCopy : public MapCopyBase<Digraph, Item, RefMap> {
 public:
 CrossRefCopy(CrossRef& cmap) : _cmap(cmap) {}
 virtual void copy(const Digraph& digraph, const RefMap& refMap) {
 typedef typename ItemSetTraits<Digraph, Item>::ItemIt ItemIt;
 for (ItemIt it(digraph); it != INVALID; ++it) {
 _cmap.set(refMap[it], it);
 }
 NodeRefMap& nodeRefMap, ArcRefMap& arcRefMap) {
 for (typename From::NodeIt it(from); it != INVALID; ++it) {
 nodeRefMap[it] = to.addNode();
 }
 for (typename From::ArcIt it(from); it != INVALID; ++it) {
 arcRefMap[it] = to.addArc(nodeRefMap[from.source(it)],
-				    nodeRefMap[from.target(it)]);
+nodeRefMap[from.target(it)]);
 }
 }
 };
 template <typename Digraph>
 struct DigraphCopySelector<
 Digraph,
 typename enable_if<typename Digraph::BuildTag, void>::type>
 {
 template <typename From, typename NodeRefMap, typename ArcRefMap>
 static void copy(Digraph &to, const From& from,
 NodeRefMap& nodeRefMap, ArcRefMap& arcRefMap) {
 to.build(from, nodeRefMap, arcRefMap);
 NodeRefMap& nodeRefMap, EdgeRefMap& edgeRefMap) {
 for (typename From::NodeIt it(from); it != INVALID; ++it) {
 nodeRefMap[it] = to.addNode();
 }
 for (typename From::EdgeIt it(from); it != INVALID; ++it) {
 edgeRefMap[it] = to.addEdge(nodeRefMap[from.u(it)],
-				      nodeRefMap[from.v(it)]);
+nodeRefMap[from.v(it)]);
 }
 }
 };
 template <typename Graph>
 struct GraphCopySelector<
 Graph,
 typename enable_if<typename Graph::BuildTag, void>::type>
 {
 template <typename From, typename NodeRefMap, typename EdgeRefMap>
 static void copy(Graph &to, const From& from,
 NodeRefMap& nodeRefMap, EdgeRefMap& edgeRefMap) {
 to.build(from, nodeRefMap, edgeRefMap);
 typedef typename To::Node TNode;
 typedef typename To::Arc TArc;
 typedef typename From::template NodeMap<TNode> NodeRefMap;
 typedef typename From::template ArcMap<TArc> ArcRefMap;
 public:
 /// \brief Constructor for the DigraphCopy.
 ///
 /// It copies the content of the \c _from digraph into the
 /// \c _to digraph.
 DigraphCopy(To& to, const From& from)
 : _from(from), _to(to) {}
 /// \brief Destructor of the DigraphCopy
 ///
 /// Destructor of the DigraphCopy
 /// should be a map, which key type is the Node type of the source
 /// graph, while the value type is the Node type of the
 /// destination graph.
 template <typename NodeRef>
 DigraphCopy& nodeRef(NodeRef& map) {
 _node_maps.push_back(new _graph_utils_bits::RefCopy<From, Node,
-			   NodeRefMap, NodeRef>(map));
+NodeRefMap, NodeRef>(map));
 return *this;
 }
 /// \brief Copies the node cross references into the given map.
 ///
 ///  is the Node type of the destination graph, while the value type is
 ///  the Node type of the source graph.
 template <typename NodeCrossRef>
 DigraphCopy& nodeCrossRef(NodeCrossRef& map) {
 _node_maps.push_back(new _graph_utils_bits::CrossRefCopy<From, Node,
-			   NodeRefMap, NodeCrossRef>(map));
+NodeRefMap, NodeCrossRef>(map));
 return *this;
 }
 /// \brief Make copy of the given map.
 ///
 /// Makes copy of the given map for the newly created digraph.
 /// The new map's key type is the destination graph's node type,
 /// and the copied map's key type is the source graph's node type.
 template <typename ToMap, typename FromMap>
 DigraphCopy& nodeMap(ToMap& tmap, const FromMap& map) {
 _node_maps.push_back(new _graph_utils_bits::MapCopy<From, Node,
-			   NodeRefMap, ToMap, FromMap>(tmap, map));
+NodeRefMap, ToMap, FromMap>(tmap, map));
 return *this;
 }
 /// \brief Make a copy of the given node.
 ///
 /// Make a copy of the given node.
 DigraphCopy& node(TNode& tnode, const Node& snode) {
 _node_maps.push_back(new _graph_utils_bits::ItemCopy<From, Node,
-			   NodeRefMap, TNode>(tnode, snode));
+NodeRefMap, TNode>(tnode, snode));
 return *this;
 }
 /// \brief Copies the arc references into the given map.
 ///
 /// Copies the arc references into the given map.
 template <typename ArcRef>
 DigraphCopy& arcRef(ArcRef& map) {
 _arc_maps.push_back(new _graph_utils_bits::RefCopy<From, Arc,
-			  ArcRefMap, ArcRef>(map));
+ArcRefMap, ArcRef>(map));
 return *this;
 }
 /// \brief Copies the arc cross references into the given map.
 ///
 ///  Copies the arc cross references (reverse references) into
 ///  the given map.
 template <typename ArcCrossRef>
 DigraphCopy& arcCrossRef(ArcCrossRef& map) {
 _arc_maps.push_back(new _graph_utils_bits::CrossRefCopy<From, Arc,
-			  ArcRefMap, ArcCrossRef>(map));
+ArcRefMap, ArcCrossRef>(map));
 return *this;
 }
 /// \brief Make copy of the given map.
 ///
 /// Makes copy of the given map for the newly created digraph.
 /// The new map's key type is the to digraph's arc type,
 /// and the copied map's key type is the from digraph's arc
 /// type.
 template <typename ToMap, typename FromMap>
 DigraphCopy& arcMap(ToMap& tmap, const FromMap& map) {
 _arc_maps.push_back(new _graph_utils_bits::MapCopy<From, Arc,
-			  ArcRefMap, ToMap, FromMap>(tmap, map));
+ArcRefMap, ToMap, FromMap>(tmap, map));
 return *this;
 }
 /// \brief Make a copy of the given arc.
 ///
 /// Make a copy of the given arc.
 DigraphCopy& arc(TArc& tarc, const Arc& sarc) {
 _arc_maps.push_back(new _graph_utils_bits::ItemCopy<From, Arc,
-			  ArcRefMap, TArc>(tarc, sarc));
+ArcRefMap, TArc>(tarc, sarc));
 return *this;
 }
 /// \brief Executes the copies.
 ///
 for (int i = 0; i < int(_node_maps.size()); ++i) {
 _node_maps[i]->copy(_from, nodeRefMap);
 }
 for (int i = 0; i < int(_arc_maps.size()); ++i) {
 _arc_maps[i]->copy(_from, arcRefMap);
 }
 }
 protected:
 const From& _from;
 To& _to;
 std::vector<_graph_utils_bits::MapCopyBase<From, Node, NodeRefMap>* >
 _node_maps;
 std::vector<_graph_utils_bits::MapCopyBase<From, Arc, ArcRefMap>* >
 _arc_maps;
 };
 /// \brief Copy a digraph to another digraph.
 /// function is detailed in the DigraphCopy class, but a short
 /// example shows a basic work:
 ///\code
 /// copyDigraph(trg, src).nodeRef(nr).arcCrossRef(ecr).run();
 ///\endcode
 ///
 /// After the copy the \c nr map will contain the mapping from the
 /// nodes of the \c from digraph to the nodes of the \c to digraph and
 /// \c ecr will contain the mapping from the arcs of the \c to digraph
 /// to the arcs of the \c from digraph.
 ///
 /// \see DigraphCopy
 template <typename To, typename From>
 DigraphCopy<To, From> copyDigraph(To& to, const From& from) {
 return DigraphCopy<To, From>(to, from);
 }
 typedef typename From::template NodeMap<TNode> NodeRefMap;
 typedef typename From::template EdgeMap<TEdge> EdgeRefMap;
 struct ArcRefMap {
 ArcRefMap(const To& to, const From& from,
-		const EdgeRefMap& edge_ref, const NodeRefMap& node_ref)
+const EdgeRefMap& edge_ref, const NodeRefMap& node_ref)
 : _to(to), _from(from),
 _edge_ref(edge_ref), _node_ref(node_ref) {}
 typedef typename From::Arc Key;
 typedef typename To::Arc Value;
 Value operator[](const Key& key) const {
 bool forward = _from.u(key) != _from.v(key) ?
-	  _node_ref[_from.source(key)] ==
+_node_ref[_from.source(key)] ==
-	  _to.source(_to.direct(_edge_ref[key], true)) :
+_to.source(_to.direct(_edge_ref[key], true)) :
-	  _from.direction(key);
+_from.direction(key);
-	return _to.direct(_edge_ref[key], forward);
+return _to.direct(_edge_ref[key], forward);
 }
 const To& _to;
 const From& _from;
 const EdgeRefMap& _edge_ref;
 const NodeRefMap& _node_ref;
 };
 public:
 /// \brief Constructor for the GraphCopy.
 ///
 /// It copies the content of the \c _from graph into the
 /// \c _to graph.
 GraphCopy(To& to, const From& from)
 : _from(from), _to(to) {}
 /// \brief Destructor of the GraphCopy
 ///
 /// Destructor of the GraphCopy
 /// \brief Copies the node references into the given map.
 ///
 /// Copies the node references into the given map.
 template <typename NodeRef>
 GraphCopy& nodeRef(NodeRef& map) {
 _node_maps.push_back(new _graph_utils_bits::RefCopy<From, Node,
-			   NodeRefMap, NodeRef>(map));
+NodeRefMap, NodeRef>(map));
 return *this;
 }
 /// \brief Copies the node cross references into the given map.
 ///
 ///  Copies the node cross references (reverse references) into
 ///  the given map.
 template <typename NodeCrossRef>
 GraphCopy& nodeCrossRef(NodeCrossRef& map) {
 _node_maps.push_back(new _graph_utils_bits::CrossRefCopy<From, Node,
-			   NodeRefMap, NodeCrossRef>(map));
+NodeRefMap, NodeCrossRef>(map));
 return *this;
 }
 /// \brief Make copy of the given map.
 ///
 /// Makes copy of the given map for the newly created graph.
 /// The new map's key type is the to graph's node type,
 /// and the copied map's key type is the from graph's node
 /// type.
 template <typename ToMap, typename FromMap>
 GraphCopy& nodeMap(ToMap& tmap, const FromMap& map) {
 _node_maps.push_back(new _graph_utils_bits::MapCopy<From, Node,
-			   NodeRefMap, ToMap, FromMap>(tmap, map));
+NodeRefMap, ToMap, FromMap>(tmap, map));
 return *this;
 }
 /// \brief Make a copy of the given node.
 ///
 /// Make a copy of the given node.
 GraphCopy& node(TNode& tnode, const Node& snode) {
 _node_maps.push_back(new _graph_utils_bits::ItemCopy<From, Node,
-			   NodeRefMap, TNode>(tnode, snode));
+NodeRefMap, TNode>(tnode, snode));
 return *this;
 }
 /// \brief Copies the arc references into the given map.
 ///
 /// Copies the arc references into the given map.
 template <typename ArcRef>
 GraphCopy& arcRef(ArcRef& map) {
 _arc_maps.push_back(new _graph_utils_bits::RefCopy<From, Arc,
-			  ArcRefMap, ArcRef>(map));
+ArcRefMap, ArcRef>(map));
 return *this;
 }
 /// \brief Copies the arc cross references into the given map.
 ///
 ///  Copies the arc cross references (reverse references) into
 ///  the given map.
 template <typename ArcCrossRef>
 GraphCopy& arcCrossRef(ArcCrossRef& map) {
 _arc_maps.push_back(new _graph_utils_bits::CrossRefCopy<From, Arc,
-			  ArcRefMap, ArcCrossRef>(map));
+ArcRefMap, ArcCrossRef>(map));
 return *this;
 }
 /// \brief Make copy of the given map.
 ///
 /// Makes copy of the given map for the newly created graph.
 /// The new map's key type is the to graph's arc type,
 /// and the copied map's key type is the from graph's arc
 /// type.
 template <typename ToMap, typename FromMap>
 GraphCopy& arcMap(ToMap& tmap, const FromMap& map) {
 _arc_maps.push_back(new _graph_utils_bits::MapCopy<From, Arc,
-			  ArcRefMap, ToMap, FromMap>(tmap, map));
+ArcRefMap, ToMap, FromMap>(tmap, map));
 return *this;
 }
 /// \brief Make a copy of the given arc.
 ///
 /// Make a copy of the given arc.
 GraphCopy& arc(TArc& tarc, const Arc& sarc) {
 _arc_maps.push_back(new _graph_utils_bits::ItemCopy<From, Arc,
-			  ArcRefMap, TArc>(tarc, sarc));
+ArcRefMap, TArc>(tarc, sarc));
 return *this;
 }
 /// \brief Copies the edge references into the given map.
 ///
 /// Copies the edge references into the given map.
 template <typename EdgeRef>
 GraphCopy& edgeRef(EdgeRef& map) {
 _edge_maps.push_back(new _graph_utils_bits::RefCopy<From, Edge,
-			   EdgeRefMap, EdgeRef>(map));
+EdgeRefMap, EdgeRef>(map));
 return *this;
 }
 /// \brief Copies the edge cross references into the given map.
 ///
 /// Copies the edge cross references (reverse
 /// references) into the given map.
 template <typename EdgeCrossRef>
 GraphCopy& edgeCrossRef(EdgeCrossRef& map) {
 _edge_maps.push_back(new _graph_utils_bits::CrossRefCopy<From,
-			   Edge, EdgeRefMap, EdgeCrossRef>(map));
+Edge, EdgeRefMap, EdgeCrossRef>(map));
 return *this;
 }
 /// \brief Make copy of the given map.
 ///
 /// Makes copy of the given map for the newly created graph.
 /// The new map's key type is the to graph's edge type,
 /// and the copied map's key type is the from graph's edge
 /// type.
 template <typename ToMap, typename FromMap>
 GraphCopy& edgeMap(ToMap& tmap, const FromMap& map) {
 _edge_maps.push_back(new _graph_utils_bits::MapCopy<From, Edge,
-			   EdgeRefMap, ToMap, FromMap>(tmap, map));
+EdgeRefMap, ToMap, FromMap>(tmap, map));
 return *this;
 }
 /// \brief Make a copy of the given edge.
 ///
 /// Make a copy of the given edge.
 GraphCopy& edge(TEdge& tedge, const Edge& sedge) {
 _edge_maps.push_back(new _graph_utils_bits::ItemCopy<From, Edge,
-			   EdgeRefMap, TEdge>(tedge, sedge));
+EdgeRefMap, TEdge>(tedge, sedge));
 return *this;
 }
 /// \brief Executes the copies.
 ///
 _arc_maps[i]->copy(_from, arcRefMap);
 }
 }
 private:
 const From& _from;
 To& _to;
 std::vector<_graph_utils_bits::MapCopyBase<From, Node, NodeRefMap>* >
 _node_maps;
 std::vector<_graph_utils_bits::MapCopyBase<From, Arc, ArcRefMap>* >
 _arc_maps;
 std::vector<_graph_utils_bits::MapCopyBase<From, Edge, EdgeRefMap>* >
 _edge_maps;
 };
 /// \brief Copy a graph to another graph.
 /// function is detailed in the GraphCopy class, but a short
 /// example shows a basic work:
 ///\code
 /// copyGraph(trg, src).nodeRef(nr).arcCrossRef(ecr).run();
 ///\endcode
 ///
 /// After the copy the \c nr map will contain the mapping from the
 /// nodes of the \c from graph to the nodes of the \c to graph and
 /// \c ecr will contain the mapping from the arcs of the \c to graph
 /// to the arcs of the \c from graph.
 ///
 /// \see GraphCopy
 template <typename To, typename From>
 GraphCopy<To, From>
 copyGraph(To& to, const From& from) {
 return GraphCopy<To, From>(to, from);
 }
 /// @}
 explicit InverseMap(const IdMap& map) : _graph(map._graph) {}
 /// \brief Gives back the given item from its id.
 ///
 /// Gives back the given item from its id.
 ///
 Item operator[](int id) const { return _graph->fromId(id, Item());}
 private:
 const Graph* _graph;
 };
 /// \brief Gives back the inverse of the map.
 ///
 /// Gives back the inverse of the IdMap.
 InverseMap inverse() const { return InverseMap(*_graph);}
 };
 /// \brief General invertable graph-map type.
 /// This type provides simple invertable graph-maps.
 /// The InvertableMap wraps an arbitrary ReadWriteMap
 /// and if a key is set to a new value then store it
 /// in the inverse map.
 ///
 /// The values of the map can be accessed
 /// with stl compatible forward iterator.
 ///
 /// \see IterableValueMap
 template <typename _Graph, typename _Item, typename _Value>
 class InvertableMap : protected DefaultMap<_Graph, _Item, _Value> {
 private:
 typedef DefaultMap<_Graph, _Item, _Value> Map;
 typedef _Graph Graph;
 typedef std::map<_Value, _Item> Container;
 Container _inv_map;
 public:
 /// The key type of InvertableMap (Node, Arc, Edge).
 typedef typename Map::Key Key;
 /// The value type of the InvertableMap.
 typedef typename Map::Value Value;
 /// \brief Constructor.
 ///
 /// Construct a new InvertableMap for the graph.
 ///
 explicit InvertableMap(const Graph& graph) : Map(graph) {}
 /// \brief Forward iterator for values.
 ///
 /// This iterator is an stl compatible forward
 /// iterator on the values of the map. The values can
 /// be accessed in the [beginValue, endValue) range.
 ///
 class ValueIterator
 : public std::iterator<std::forward_iterator_tag, Value> {
 friend class InvertableMap;
 private:
 ValueIterator(typename Container::const_iterator _it)
 : it(_it) {}
 public:
 ValueIterator() {}
 ValueIterator& operator++() { ++it; return *this; }
 ValueIterator operator++(int) {
 ValueIterator tmp(*this);
 operator++();
 return tmp;
 }
 const Value& operator*() const { return it->first; }
 const Value* operator->() const { return &(it->first); }
 bool operator==(ValueIterator jt) const { return it == jt.it; }
 bool operator!=(ValueIterator jt) const { return it != jt.it; }
 private:
 typename Container::const_iterator it;
 };
 /// \brief Returns an iterator to the first value.
 ///
 /// Returns an stl compatible iterator to the
 /// first value of the map. The values of the
 /// map can be accessed in the [beginValue, endValue)
 /// range.
 ValueIterator beginValue() const {
 return ValueIterator(_inv_map.begin());
 }
 /// \brief Returns an iterator after the last value.
 ///
 /// Returns an stl compatible iterator after the
 /// last value of the map. The values of the
 /// map can be accessed in the [beginValue, endValue)
 /// range.
 ValueIterator endValue() const {
 return ValueIterator(_inv_map.end());
 }
 /// \brief The setter function of the map.
 ///
 /// Sets the mapped value.
 void set(const Key& key, const Value& val) {
 Value oldval = Map::operator[](key);
 typename Container::iterator it = _inv_map.find(oldval);
 if (it != _inv_map.end() && it->second == key) {
-	_inv_map.erase(it);
+_inv_map.erase(it);
 }
 _inv_map.insert(make_pair(val, key));
 Map::set(key, val);
 }
 /// \brief The getter function of the map.
 ///
 /// It gives back the value associated with the key.
 typename MapTraits<Map>::ConstReturnValue
 operator[](const Key& key) const {
 return Map::operator[](key);
 }
 /// \brief Gives back the item by its value.
 /// \c AlterationNotifier.
 virtual void erase(const Key& key) {
 Value val = Map::operator[](key);
 typename Container::iterator it = _inv_map.find(val);
 if (it != _inv_map.end() && it->second == key) {
-	_inv_map.erase(it);
+_inv_map.erase(it);
 }
 Map::erase(key);
 }
 /// \brief Erase more keys from the map.
 ///
 /// Erase more keys from the map. It is called by the
 /// \c AlterationNotifier.
 virtual void erase(const std::vector<Key>& keys) {
 for (int i = 0; i < int(keys.size()); ++i) {
-	Value val = Map::operator[](keys[i]);
+Value val = Map::operator[](keys[i]);
-	typename Container::iterator it = _inv_map.find(val);
+typename Container::iterator it = _inv_map.find(val);
-	if (it != _inv_map.end() && it->second == keys[i]) {
+if (it != _inv_map.end() && it->second == keys[i]) {
-	  _inv_map.erase(it);
+_inv_map.erase(it);
-	}
+}
 }
 Map::erase(keys);
 }
 /// \brief Clear the keys from the map and inverse map.
 public:
 /// \brief The inverse map type.
 ///
 /// The inverse of this map. The subscript operator of the map
 /// gives back always the item what was last assigned to the value.
 class InverseMap {
 public:
 /// \brief Constructor of the InverseMap.
 ///
 /// Constructor of the InverseMap.
 explicit InverseMap(const InvertableMap& inverted)
 : _inverted(inverted) {}
 /// The value type of the InverseMap.
 typedef typename InvertableMap::Key Value;
 /// The key type of the InverseMap.
 typedef typename InvertableMap::Value Key;
 /// \brief Subscript operator.
 ///
 /// Subscript operator. It gives back always the item
 /// what was last assigned to the value.
 Value operator[](const Key& key) const {
-	return _inverted(key);
+return _inverted(key);
 }
 private:
 const InvertableMap& _inverted;
 };
 /// \brief It gives back the just readable inverse map.
 ///
 /// It gives back the just readable inverse map.
 InverseMap inverse() const {
 return InverseMap(*this);
 }
 };
 /// \brief Provides a mutable, continuous and unique descriptor for each
 /// item in the graph.
 ///
 /// The DescriptorMap class provides a unique and continuous (but mutable)
 /// descriptor (id) for each item of the same type (e.g. node) in the
 /// graph. This id is <ul><li>\b unique: different items (nodes) get
 /// this type (e.g. nodes) (so the id of a node can change if you delete an
 /// other node, i.e. this id is mutable).  </ul> This map can be inverted
 /// with its member class \c InverseMap, or with the \c operator() member.
 ///
 /// \tparam _Graph The graph class the \c DescriptorMap belongs to.
 /// \tparam _Item The Item is the Key of the Map. It may be Node, Arc or
 /// Edge.
 template <typename _Graph, typename _Item>
 class DescriptorMap : protected DefaultMap<_Graph, _Item, int> {
 typedef _Item Item;
 /// \brief Constructor.
 ///
 /// Constructor for descriptor map.
 explicit DescriptorMap(const Graph& _graph) : Map(_graph) {
 Item it;
 const typename Map::Notifier* nf = Map::notifier();
 for (nf->first(it); it != INVALID; nf->next(it)) {
-	Map::set(it, _inv_map.size());
+Map::set(it, _inv_map.size());
-	_inv_map.push_back(it);
+_inv_map.push_back(it);
 }
 }
 protected:
 /// \brief Add a new key to the map.
 /// Add more new keys to the map. It is called by the
 /// \c AlterationNotifier.
 virtual void add(const std::vector<Item>& items) {
 Map::add(items);
 for (int i = 0; i < int(items.size()); ++i) {
-	Map::set(items[i], _inv_map.size());
+Map::set(items[i], _inv_map.size());
-	_inv_map.push_back(items[i]);
+_inv_map.push_back(items[i]);
 }
 }
 /// \brief Erase the key from the map.
 ///
 ///
 /// Erase more keys from the map. It is called by the
 /// \c AlterationNotifier.
 virtual void erase(const std::vector<Item>& items) {
 for (int i = 0; i < int(items.size()); ++i) {
-	Map::set(_inv_map.back(), Map::operator[](items[i]));
+Map::set(_inv_map.back(), Map::operator[](items[i]));
-	_inv_map[Map::operator[](items[i])] = _inv_map.back();
+_inv_map[Map::operator[](items[i])] = _inv_map.back();
-	_inv_map.pop_back();
+_inv_map.pop_back();
 }
 Map::erase(items);
 }
 /// \brief Build the unique map.
 /// Build the unique map. It is called by the
 /// \c AlterationNotifier.
 virtual void build() {
 Map::build();
 Item it;
 const typename Map::Notifier* nf = Map::notifier();
 for (nf->first(it); it != INVALID; nf->next(it)) {
-	Map::set(it, _inv_map.size());
+Map::set(it, _inv_map.size());
-	_inv_map.push_back(it);
+_inv_map.push_back(it);
 }
 }
 /// \brief Clear the keys from the map.
 ///
 /// Clear the keys from the map. It is called by the
 /// \c AlterationNotifier.
 virtual void clear() {
 ///
 /// Gives back th item by its descriptor.
 Item operator()(int id) const {
 return _inv_map[id];
 }
 private:
 typedef std::vector<Item> Container;
 Container _inv_map;
 class InverseMap {
 public:
 /// \brief Constructor of the InverseMap.
 ///
 /// Constructor of the InverseMap.
 explicit InverseMap(const DescriptorMap& inverted)
-	: _inverted(inverted) {}
+: _inverted(inverted) {}
 /// The value type of the InverseMap.
 typedef typename DescriptorMap::Key Value;
 /// The key type of the InverseMap.
 typedef typename DescriptorMap::Value Key;
 /// \brief Subscript operator.
 ///
 /// Subscript operator. It gives back the item
 /// that the descriptor belongs to currently.
 Value operator[](const Key& key) const {
-	return _inverted(key);
+return _inverted(key);
 }
 /// \brief Size of the map.
 ///
 /// Returns the size of the map.
 unsigned int size() const {
-	return _inverted.size();
+return _inverted.size();
 }
 private:
 const DescriptorMap& _inverted;
 };
 /// \brief Gives back the inverse of the map.
 }
 };
 /// \brief Returns the source of the given arc.
 ///
 /// The SourceMap gives back the source Node of the given arc.
 /// \see TargetMap
 template <typename Digraph>
 class SourceMap {
 public:
 explicit SourceMap(const Digraph& digraph) : _digraph(digraph) {}
 /// \brief The subscript operator.
 ///
 /// The subscript operator.
 /// \param arc The arc
 /// \return The source of the arc
 Value operator[](const Key& arc) const {
 return _digraph.source(arc);
 }
 private:
 /// This function just returns an \ref SourceMap class.
 /// \relates SourceMap
 template <typename Digraph>
 inline SourceMap<Digraph> sourceMap(const Digraph& digraph) {
 return SourceMap<Digraph>(digraph);
 }
 /// \brief Returns the target of the given arc.
 ///
 /// The TargetMap gives back the target Node of the given arc.
 /// \see SourceMap
 template <typename Digraph>
 class TargetMap {
 public:
 explicit TargetMap(const Digraph& digraph) : _digraph(digraph) {}
 /// \brief The subscript operator.
 ///
 /// The subscript operator.
 /// \param e The arc
 /// \return The target of the arc
 Value operator[](const Key& e) const {
 return _digraph.target(e);
 }
 private:
 explicit ForwardMap(const Graph& graph) : _graph(graph) {}
 /// \brief The subscript operator.
 ///
 /// The subscript operator.
 /// \param key An edge
 /// \return The "forward" directed arc view of edge
 Value operator[](const Key& key) const {
 return _graph.direct(key, true);
 }
 private:
 explicit BackwardMap(const Graph& graph) : _graph(graph) {}
 /// \brief The subscript operator.
 ///
 /// The subscript operator.
 /// \param key An edge
 /// \return The "backward" directed arc view of edge
 Value operator[](const Key& key) const {
 return _graph.direct(key, false);
 }
 private:
 typedef typename NodeMap::Value Value;
 /// \brief Constructor
 ///
 /// Contructor of the map
 explicit PotentialDifferenceMap(const Digraph& digraph,
 const NodeMap& potential)
 : _digraph(digraph), _potential(potential) {}
 /// \brief Const subscription operator
 ///
 /// Const subscription operator
 Value operator[](const Key& arc) const {
 return _potential[_digraph.target(arc)] -
-	_potential[_digraph.source(arc)];
+_potential[_digraph.source(arc)];
 }
 private:
 const Digraph& _digraph;
 const NodeMap& _potential;
 /// \brief Returns a PotentialDifferenceMap.
 ///
 /// This function just returns a PotentialDifferenceMap.
 /// \relates PotentialDifferenceMap
 template <typename Digraph, typename NodeMap>
 PotentialDifferenceMap<Digraph, NodeMap>
 potentialDifferenceMap(const Digraph& digraph, const NodeMap& potential) {
 return PotentialDifferenceMap<Digraph, NodeMap>(digraph, potential);
 }
 /// \brief Map of the node in-degrees.
 /// of \ref ListDigraph will \e not update the degree values correctly.
 ///
 /// \sa OutDegMap
 template <typename _Digraph>
 class InDegMap
 : protected ItemSetTraits<_Digraph, typename _Digraph::Arc>
 ::ItemNotifier::ObserverBase {
 public:
 typedef _Digraph Digraph;
 typedef int Value;
 typedef typename Digraph::Node Key;
 typedef typename ItemSetTraits<Digraph, typename Digraph::Arc>
 public:
 typedef DefaultMap<Digraph, Key, int> Parent;
 AutoNodeMap(const Digraph& digraph) : Parent(digraph, 0) {}
 virtual void add(const Key& key) {
-	Parent::add(key);
+Parent::add(key);
-	Parent::set(key, 0);
+Parent::set(key, 0);
 }
 virtual void add(const std::vector<Key>& keys) {
-	Parent::add(keys);
+Parent::add(keys);
-	for (int i = 0; i < int(keys.size()); ++i) {
+for (int i = 0; i < int(keys.size()); ++i) {
-	  Parent::set(keys[i], 0);
+Parent::set(keys[i], 0);
-	}
+}
 }
 virtual void build() {
-	Parent::build();
+Parent::build();
-	Key it;
+Key it;
-	typename Parent::Notifier* nf = Parent::notifier();
+typename Parent::Notifier* nf = Parent::notifier();
-	for (nf->first(it); it != INVALID; nf->next(it)) {
+for (nf->first(it); it != INVALID; nf->next(it)) {
-	  Parent::set(it, 0);
+Parent::set(it, 0);
-	}
+}
 }
 };
 public:
 /// \brief Constructor.
 ///
 /// Constructor for creating in-degree map.
 explicit InDegMap(const Digraph& digraph)
 : _digraph(digraph), _deg(digraph) {
 Parent::attach(_digraph.notifier(typename Digraph::Arc()));
 for(typename Digraph::NodeIt it(_digraph); it != INVALID; ++it) {
-	_deg[it] = countInArcs(_digraph, it);
+_deg[it] = countInArcs(_digraph, it);
 }
 }
 /// Gives back the in-degree of a Node.
 int operator[](const Key& key) const {
 return _deg[key];
 }
 protected:
 typedef typename Digraph::Arc Arc;
 virtual void add(const Arc& arc) {
 ++_deg[_digraph.target(arc)];
 }
 }
 }
 virtual void build() {
 for(typename Digraph::NodeIt it(_digraph); it != INVALID; ++it) {
-	_deg[it] = countInArcs(_digraph, it);
+_deg[it] = countInArcs(_digraph, it);
 }
 }
 virtual void clear() {
 for(typename Digraph::NodeIt it(_digraph); it != INVALID; ++it) {
-	_deg[it] = 0;
+_deg[it] = 0;
 }
 }
 private:
 const Digraph& _digraph;
 AutoNodeMap _deg;
 };
 /// \brief Map of the node out-degrees.
 /// of \ref ListDigraph will \e not update the degree values correctly.
 ///
 /// \sa InDegMap
 template <typename _Digraph>
 class OutDegMap
 : protected ItemSetTraits<_Digraph, typename _Digraph::Arc>
 ::ItemNotifier::ObserverBase {
 public:
 typedef _Digraph Digraph;
 typedef int Value;
 typedef typename Digraph::Node Key;
 typedef typename ItemSetTraits<Digraph, typename Digraph::Arc>
 public:
 typedef DefaultMap<Digraph, Key, int> Parent;
 AutoNodeMap(const Digraph& digraph) : Parent(digraph, 0) {}
 virtual void add(const Key& key) {
-	Parent::add(key);
+Parent::add(key);
-	Parent::set(key, 0);
+Parent::set(key, 0);
 }
 virtual void add(const std::vector<Key>& keys) {
-	Parent::add(keys);
+Parent::add(keys);
-	for (int i = 0; i < int(keys.size()); ++i) {
+for (int i = 0; i < int(keys.size()); ++i) {
-	  Parent::set(keys[i], 0);
+Parent::set(keys[i], 0);
-	}
+}
 }
 virtual void build() {
-	Parent::build();
+Parent::build();
-	Key it;
+Key it;
-	typename Parent::Notifier* nf = Parent::notifier();
+typename Parent::Notifier* nf = Parent::notifier();
-	for (nf->first(it); it != INVALID; nf->next(it)) {
+for (nf->first(it); it != INVALID; nf->next(it)) {
-	  Parent::set(it, 0);
+Parent::set(it, 0);
-	}
+}
 }
 };
 public:
 /// \brief Constructor.
 ///
 /// Constructor for creating out-degree map.
 explicit OutDegMap(const Digraph& digraph)
 : _digraph(digraph), _deg(digraph) {
 Parent::attach(_digraph.notifier(typename Digraph::Arc()));
 for(typename Digraph::NodeIt it(_digraph); it != INVALID; ++it) {
-	_deg[it] = countOutArcs(_digraph, it);
+_deg[it] = countOutArcs(_digraph, it);
 }
 }
 /// Gives back the out-degree of a Node.
 int operator[](const Key& key) const {
 return _deg[key];
 }
 protected:
 typedef typename Digraph::Arc Arc;
 virtual void add(const Arc& arc) {
 ++_deg[_digraph.source(arc)];
 }
 }
 }
 virtual void build() {
 for(typename Digraph::NodeIt it(_digraph); it != INVALID; ++it) {
-	_deg[it] = countOutArcs(_digraph, it);
+_deg[it] = countOutArcs(_digraph, it);
 }
 }
 virtual void clear() {
 for(typename Digraph::NodeIt it(_digraph); it != INVALID; ++it) {
-	_deg[it] = 0;
+_deg[it] = 0;
 }
 }
 private:
 const Digraph& _digraph;
 AutoNodeMap _deg;
 };
 ///Dynamic arc look up between given endpoints.
 ///\ingroup gutils
 ///Using this class, you can find an arc in a digraph from a given
 ///source to a given target in amortized time <em>O(log d)</em>,
 ///where <em>d</em> is the out-degree of the source node.
 ///
 ///and Tarjan's Splay tree for guarantee the logarithmic amortized
 ///time bound for arc lookups. This class also guarantees the
 ///optimal time bound in a constant factor for any distribution of
 ///queries.
 ///
 ///\tparam G The type of the underlying digraph.
 ///
 ///\sa ArcLookUp
 ///\sa AllArcLookUp
 template<class G>
 class DynArcLookUp
 : protected ItemSetTraits<G, typename G::Arc>::ItemNotifier::ObserverBase
 {
 public:
 typedef typename ItemSetTraits<G, typename G::Arc>
 ::ItemNotifier::ObserverBase Parent;
 public:
 typedef DefaultMap<G, Node, Arc> Parent;
 AutoNodeMap(const G& digraph) : Parent(digraph, INVALID) {}
 virtual void add(const Node& node) {
-	Parent::add(node);
+Parent::add(node);
-	Parent::set(node, INVALID);
+Parent::set(node, INVALID);
 }
 virtual void add(const std::vector<Node>& nodes) {
-	Parent::add(nodes);
+Parent::add(nodes);
-	for (int i = 0; i < int(nodes.size()); ++i) {
+for (int i = 0; i < int(nodes.size()); ++i) {
-	  Parent::set(nodes[i], INVALID);
+Parent::set(nodes[i], INVALID);
-	}
+}
 }
 virtual void build() {
-	Parent::build();
+Parent::build();
-	Node it;
+Node it;
-	typename Parent::Notifier* nf = Parent::notifier();
+typename Parent::Notifier* nf = Parent::notifier();
-	for (nf->first(it); it != INVALID; nf->next(it)) {
+for (nf->first(it); it != INVALID; nf->next(it)) {
-	  Parent::set(it, INVALID);
+Parent::set(it, INVALID);
-	}
+}
 }
 };
 const Digraph &_g;
 AutoNodeMap _head;
 typename Digraph::template ArcMap<Arc> _parent;
 typename Digraph::template ArcMap<Arc> _left;
 typename Digraph::template ArcMap<Arc> _right;
 class ArcLess {
 const Digraph &g;
 public:
 ArcLess(const Digraph &_g) : g(_g) {}
 bool operator()(Arc a,Arc b) const
 {
-	return g.target(a)<g.target(b);
+return g.target(a)<g.target(b);
 }
 };
 public:
 ///Constructor
 ///Constructor.
 ///
 ///It builds up the search database.
 DynArcLookUp(const Digraph &g)
 : _g(g),_head(g),_parent(g),_left(g),_right(g)
 {
 Parent::attach(_g.notifier(typename Digraph::Arc()));
 refresh();
 }
 protected:
 virtual void add(const Arc& arc) {
 insert(arc);
 }
 virtual void add(const std::vector<Arc>& arcs) {
 for (int i = 0; i < int(arcs.size()); ++i) {
-	insert(arcs[i]);
+insert(arcs[i]);
 }
 }
 virtual void erase(const Arc& arc) {
 remove(arc);
 }
 virtual void erase(const std::vector<Arc>& arcs) {
 for (int i = 0; i < int(arcs.size()); ++i) {
-	remove(arcs[i]);
+remove(arcs[i]);
 }
 }
 virtual void build() {
 refresh();
 }
 virtual void clear() {
 for(NodeIt n(_g);n!=INVALID;++n) {
-	_head.set(n, INVALID);
+_head.set(n, INVALID);
 }
 }
 void insert(Arc arc) {
 Node s = _g.source(arc);
 Node t = _g.target(arc);
 _left.set(arc, INVALID);
 _right.set(arc, INVALID);
 Arc e = _head[s];
 if (e == INVALID) {
-	_head.set(s, arc);
+_head.set(s, arc);
-	_parent.set(arc, INVALID);
+_parent.set(arc, INVALID);
-	return;
+return;
 }
 while (true) {
-	if (t < _g.target(e)) {
+if (t < _g.target(e)) {
-	  if (_left[e] == INVALID) {
+if (_left[e] == INVALID) {
-	    _left.set(e, arc);
+_left.set(e, arc);
-	    _parent.set(arc, e);
+_parent.set(arc, e);
-	    splay(arc);
+splay(arc);
-	    return;
+return;
-	  } else {
+} else {
-	    e = _left[e];
+e = _left[e];
-	  }
+}
-	} else {
+} else {
-	  if (_right[e] == INVALID) {
+if (_right[e] == INVALID) {
-	    _right.set(e, arc);
+_right.set(e, arc);
-	    _parent.set(arc, e);
+_parent.set(arc, e);
-	    splay(arc);
+splay(arc);
-	    return;
+return;
-	  } else {
+} else {
-	    e = _right[e];
+e = _right[e];
-	  }
+}
-	}
+}
 }
 }
 void remove(Arc arc) {
 if (_left[arc] == INVALID) {
-	if (_right[arc] != INVALID) {
+if (_right[arc] != INVALID) {
-	  _parent.set(_right[arc], _parent[arc]);
+_parent.set(_right[arc], _parent[arc]);
-	}
+}
-	if (_parent[arc] != INVALID) {
+if (_parent[arc] != INVALID) {
-	  if (_left[_parent[arc]] == arc) {
+if (_left[_parent[arc]] == arc) {
-	    _left.set(_parent[arc], _right[arc]);
+_left.set(_parent[arc], _right[arc]);
-	  } else {
+} else {
-	    _right.set(_parent[arc], _right[arc]);
+_right.set(_parent[arc], _right[arc]);
-	  }
+}
-	} else {
+} else {
-	  _head.set(_g.source(arc), _right[arc]);
+_head.set(_g.source(arc), _right[arc]);
-	}
+}
 } else if (_right[arc] == INVALID) {
-	_parent.set(_left[arc], _parent[arc]);
+_parent.set(_left[arc], _parent[arc]);
-	if (_parent[arc] != INVALID) {
+if (_parent[arc] != INVALID) {
-	  if (_left[_parent[arc]] == arc) {
+if (_left[_parent[arc]] == arc) {
-	    _left.set(_parent[arc], _left[arc]);
+_left.set(_parent[arc], _left[arc]);
-	  } else {
+} else {
-	    _right.set(_parent[arc], _left[arc]);
+_right.set(_parent[arc], _left[arc]);
-	  }
+}
-	} else {
+} else {
-	  _head.set(_g.source(arc), _left[arc]);
+_head.set(_g.source(arc), _left[arc]);
-	}
+}
 } else {
-	Arc e = _left[arc];
+Arc e = _left[arc];
-	if (_right[e] != INVALID) {
+if (_right[e] != INVALID) {
-	  e = _right[e];
+e = _right[e];
-	  while (_right[e] != INVALID) {
+while (_right[e] != INVALID) {
-	    e = _right[e];
+e = _right[e];
-	  }
+}
-	  Arc s = _parent[e];
+Arc s = _parent[e];
-	  _right.set(_parent[e], _left[e]);
+_right.set(_parent[e], _left[e]);
-	  if (_left[e] != INVALID) {
+if (_left[e] != INVALID) {
-	    _parent.set(_left[e], _parent[e]);
+_parent.set(_left[e], _parent[e]);
-	  }
+}
-	  _left.set(e, _left[arc]);
+_left.set(e, _left[arc]);
-	  _parent.set(_left[arc], e);
+_parent.set(_left[arc], e);
-	  _right.set(e, _right[arc]);
+_right.set(e, _right[arc]);
-	  _parent.set(_right[arc], e);
+_parent.set(_right[arc], e);
-	  _parent.set(e, _parent[arc]);
+_parent.set(e, _parent[arc]);
-	  if (_parent[arc] != INVALID) {
+if (_parent[arc] != INVALID) {
-	    if (_left[_parent[arc]] == arc) {
+if (_left[_parent[arc]] == arc) {
-	      _left.set(_parent[arc], e);
+_left.set(_parent[arc], e);
-	    } else {
+} else {
-	      _right.set(_parent[arc], e);
+_right.set(_parent[arc], e);
-	    }
+}
-	  }
+}
-	  splay(s);
+splay(s);
-	} else {
+} else {
-	  _right.set(e, _right[arc]);
+_right.set(e, _right[arc]);
-	  _parent.set(_right[arc], e);
+_parent.set(_right[arc], e);
-	  if (_parent[arc] != INVALID) {
+if (_parent[arc] != INVALID) {
-	    if (_left[_parent[arc]] == arc) {
+if (_left[_parent[arc]] == arc) {
-	      _left.set(_parent[arc], e);
+_left.set(_parent[arc], e);
-	    } else {
+} else {
-	      _right.set(_parent[arc], e);
+_right.set(_parent[arc], e);
-	    }
+}
-	  } else {
+} else {
-	    _head.set(_g.source(arc), e);
+_head.set(_g.source(arc), e);
-	  }
+}
-	}
+}
 }
 }
 Arc refreshRec(std::vector<Arc> &v,int a,int b)
 {
 int m=(a+b)/2;
 Arc me=v[m];
 if (a < m) {
-	Arc left = refreshRec(v,a,m-1);
+Arc left = refreshRec(v,a,m-1);
-	_left.set(me, left);
+_left.set(me, left);
-	_parent.set(left, me);
+_parent.set(left, me);
 } else {
-	_left.set(me, INVALID);
+_left.set(me, INVALID);
 }
 if (m < b) {
-	Arc right = refreshRec(v,m+1,b);
+Arc right = refreshRec(v,m+1,b);
-	_right.set(me, right);
+_right.set(me, right);
-	_parent.set(right, me);
+_parent.set(right, me);
 } else {
-	_right.set(me, INVALID);
+_right.set(me, INVALID);
 }
 return me;
 }
 void refresh() {
 for(NodeIt n(_g);n!=INVALID;++n) {
-	std::vector<Arc> v;
+std::vector<Arc> v;
-	for(OutArcIt e(_g,n);e!=INVALID;++e) v.push_back(e);
+for(OutArcIt e(_g,n);e!=INVALID;++e) v.push_back(e);
-	if(v.size()) {
+if(v.size()) {
-	  std::sort(v.begin(),v.end(),ArcLess(_g));
+std::sort(v.begin(),v.end(),ArcLess(_g));
-	  Arc head = refreshRec(v,0,v.size()-1);
+Arc head = refreshRec(v,0,v.size()-1);
-	  _head.set(n, head);
+_head.set(n, head);
-	  _parent.set(head, INVALID);
+_parent.set(head, INVALID);
-	}
+}
-	else _head.set(n, INVALID);
+else _head.set(n, INVALID);
 }
 }
 void zig(Arc v) {
 Arc w = _parent[v];
 _parent.set(v, _parent[w]);
 _parent.set(w, v);
 _left.set(w, _right[v]);
 _right.set(v, w);
 if (_parent[v] != INVALID) {
-	if (_right[_parent[v]] == w) {
+if (_right[_parent[v]] == w) {
-	  _right.set(_parent[v], v);
+_right.set(_parent[v], v);
-	} else {
+} else {
-	  _left.set(_parent[v], v);
+_left.set(_parent[v], v);
-	}
+}
 }
 if (_left[w] != INVALID){
-	_parent.set(_left[w], w);
+_parent.set(_left[w], w);
 }
 }
 void zag(Arc v) {
 Arc w = _parent[v];
 _parent.set(v, _parent[w]);
 _parent.set(w, v);
 _right.set(w, _left[v]);
 _left.set(v, w);
 if (_parent[v] != INVALID){
-	if (_left[_parent[v]] == w) {
+if (_left[_parent[v]] == w) {
-	  _left.set(_parent[v], v);
+_left.set(_parent[v], v);
-	} else {
+} else {
-	  _right.set(_parent[v], v);
+_right.set(_parent[v], v);
-	}
+}
 }
 if (_right[w] != INVALID){
-	_parent.set(_right[w], w);
+_parent.set(_right[w], w);
 }
 }
 void splay(Arc v) {
 while (_parent[v] != INVALID) {
-	if (v == _left[_parent[v]]) {
+if (v == _left[_parent[v]]) {
-	  if (_parent[_parent[v]] == INVALID) {
+if (_parent[_parent[v]] == INVALID) {
-	    zig(v);
+zig(v);
-	  } else {
+} else {
-	    if (_parent[v] == _left[_parent[_parent[v]]]) {
+if (_parent[v] == _left[_parent[_parent[v]]]) {
-	      zig(_parent[v]);
+zig(_parent[v]);
-	      zig(v);
+zig(v);
-	    } else {
+} else {
-	      zig(v);
+zig(v);
-	      zag(v);
+zag(v);
-	    }
+}
-	  }
+}
-	} else {
+} else {
-	  if (_parent[_parent[v]] == INVALID) {
+if (_parent[_parent[v]] == INVALID) {
-	    zag(v);
+zag(v);
-	  } else {
+} else {
-	    if (_parent[v] == _left[_parent[_parent[v]]]) {
+if (_parent[v] == _left[_parent[_parent[v]]]) {
-	      zag(v);
+zag(v);
-	      zig(v);
+zig(v);
-	    } else {
+} else {
-	      zag(_parent[v]);
+zag(_parent[v]);
-	      zag(v);
+zag(v);
-	    }
+}
-	  }
+}
-	}
+}
 }
 _head[_g.source(v)] = v;
 }
 public:
 ///Find an arc between two nodes.
 ///Find an arc between two nodes in time <em>O(</em>log<em>d)</em>, where
 /// <em>d</em> is the number of outgoing arcs of \c s.
 ///\param s The source node
 ///\param t The target node
 ///\return An arc from \c s to \c t if there exists,
 ///\ref INVALID otherwise.
 Arc operator()(Node s, Node t) const
 {
 Arc a = _head[s];
 while (true) {
-	if (_g.target(a) == t) {
+if (_g.target(a) == t) {
-	  const_cast<DynArcLookUp&>(*this).splay(a);
+const_cast<DynArcLookUp&>(*this).splay(a);
-	  return a;
+return a;
-	} else if (t < _g.target(a)) {
+} else if (t < _g.target(a)) {
-	  if (_left[a] == INVALID) {
+if (_left[a] == INVALID) {
-	    const_cast<DynArcLookUp&>(*this).splay(a);
+const_cast<DynArcLookUp&>(*this).splay(a);
-	    return INVALID;
+return INVALID;
-	  } else {
+} else {
-	    a = _left[a];
+a = _left[a];
-	  }
+}
-	} else  {
+} else  {
-	  if (_right[a] == INVALID) {
+if (_right[a] == INVALID) {
-	    const_cast<DynArcLookUp&>(*this).splay(a);
+const_cast<DynArcLookUp&>(*this).splay(a);
-	    return INVALID;
+return INVALID;
-	  } else {
+} else {
-	    a = _right[a];
+a = _right[a];
-	  }
+}
-	}
+}
 }
 }
 ///Find the first arc between two nodes.
 ///Find the first arc between two nodes in time
 /// <em>O(</em>log<em>d)</em>, where <em>d</em> is the number of
 /// outgoing arcs of \c s.
 ///\param s The source node
 ///\param t The target node
 ///\return An arc from \c s to \c t if there exists, \ref INVALID
 /// otherwise.
 Arc findFirst(Node s, Node t) const
 {
 Arc a = _head[s];
 Arc r = INVALID;
 while (true) {
-	if (_g.target(a) < t) {
+if (_g.target(a) < t) {
-	  if (_right[a] == INVALID) {
+if (_right[a] == INVALID) {
-	    const_cast<DynArcLookUp&>(*this).splay(a);
+const_cast<DynArcLookUp&>(*this).splay(a);
-	    return r;
+return r;
-	  } else {
+} else {
-	    a = _right[a];
+a = _right[a];
-	  }
+}
-	} else {
+} else {
-	  if (_g.target(a) == t) {
+if (_g.target(a) == t) {
-	    r = a;
+r = a;
-	  }
+}
-	  if (_left[a] == INVALID) {
+if (_left[a] == INVALID) {
-	    const_cast<DynArcLookUp&>(*this).splay(a);
+const_cast<DynArcLookUp&>(*this).splay(a);
-	    return r;
+return r;
-	  } else {
+} else {
-	    a = _left[a];
+a = _left[a];
-	  }
+}
-	}
+}
 }
 }
 ///Find the next arc between two nodes.
 ///Find the next arc between two nodes in time
 /// <em>O(</em>log<em>d)</em>, where <em>d</em> is the number of
 /// outgoing arcs of \c s.
 ///\param s The source node
 ///\param t The target node
 ///\return An arc from \c s to \c t if there exists, \ref INVALID
 /// otherwise.
 ///\note If \c e is not the result of the previous \c findFirst()
 #else
 Arc findNext(Node, Node t, Arc a) const
 #endif
 {
 if (_right[a] != INVALID) {
-	a = _right[a];
+a = _right[a];
-	while (_left[a] != INVALID) {
+while (_left[a] != INVALID) {
-	  a = _left[a];
+a = _left[a];
-	}
+}
-	const_cast<DynArcLookUp&>(*this).splay(a);
+const_cast<DynArcLookUp&>(*this).splay(a);
 } else {
-	while (_parent[a] != INVALID && _right[_parent[a]] ==  a) {
+while (_parent[a] != INVALID && _right[_parent[a]] ==  a) {
-	  a = _parent[a];
+a = _parent[a];
-	}
+}
-	if (_parent[a] == INVALID) {
+if (_parent[a] == INVALID) {
-	  return INVALID;
+return INVALID;
-	} else {
+} else {
-	  a = _parent[a];
+a = _parent[a];
-	  const_cast<DynArcLookUp&>(*this).splay(a);
+const_cast<DynArcLookUp&>(*this).splay(a);
-	}
+}
 }
 if (_g.target(a) == t) return a;
 else return INVALID;
 }
 };
 ///Fast arc look up between given endpoints.
 ///\ingroup gutils
 ///Using this class, you can find an arc in a digraph from a given
 ///source to a given target in time <em>O(log d)</em>,
 ///where <em>d</em> is the out-degree of the source node.
 ///
 ///proportional (<em>O(m</em>log<em>m)</em>) to the number of arcs).
 ///
 ///\tparam G The type of the underlying digraph.
 ///
 ///\sa DynArcLookUp
 ///\sa AllArcLookUp
 template<class G>
 class ArcLookUp
 {
 public:
 TEMPLATE_DIGRAPH_TYPEDEFS(G);
 typedef G Digraph;
 protected:
 const Digraph &_g;
 typename Digraph::template NodeMap<Arc> _head;
 typename Digraph::template ArcMap<Arc> _left;
 typename Digraph::template ArcMap<Arc> _right;
 class ArcLess {
 const Digraph &g;
 public:
 ArcLess(const Digraph &_g) : g(_g) {}
 bool operator()(Arc a,Arc b) const
 {
-	return g.target(a)<g.target(b);
+return g.target(a)<g.target(b);
 }
 };
 public:
 ///Constructor
 ///Constructor.
 ///
 ///It builds up the search database, which remains valid until the digraph
 ///changes.
 ArcLookUp(const Digraph &g) :_g(g),_head(g),_left(g),_right(g) {refresh();}
 private:
 Arc refreshRec(std::vector<Arc> &v,int a,int b)
 {
 int m=(a+b)/2;
 Arc me=v[m];
 _left[me] = a<m?refreshRec(v,a,m-1):INVALID;
 _right[me] = m<b?refreshRec(v,m+1,b):INVALID;
 ///Build up the search database of node \c n.
 ///
 ///It runs in time <em>O(d</em>log<em>d)</em>, where <em>d</em> is
 ///the number of the outgoing arcs of \c n.
 void refresh(Node n)
 {
 std::vector<Arc> v;
 for(OutArcIt e(_g,n);e!=INVALID;++e) v.push_back(e);
 if(v.size()) {
-	std::sort(v.begin(),v.end(),ArcLess(_g));
+std::sort(v.begin(),v.end(),ArcLess(_g));
-	_head[n]=refreshRec(v,0,v.size()-1);
+_head[n]=refreshRec(v,0,v.size()-1);
 }
 else _head[n]=INVALID;
 }
 ///Refresh the full data structure.
 ///
 ///It runs in time <em>O(m</em>log<em>D)</em>, where <em>m</em> is
 ///the number of the arcs of \c n and <em>D</em> is the maximum
 ///out-degree of the digraph.
 void refresh()
 {
 for(NodeIt n(_g);n!=INVALID;++n) refresh(n);
 }
 ///Find an arc between two nodes.
 ///Find an arc between two nodes in time <em>O(</em>log<em>d)</em>, where
 /// <em>d</em> is the number of outgoing arcs of \c s.
 ///\param s The source node
 ///\param t The target node
 ///\return An arc from \c s to \c t if there exists,
 ///
 Arc operator()(Node s, Node t) const
 {
 Arc e;
 for(e=_head[s];
-	  e!=INVALID&&_g.target(e)!=t;
+e!=INVALID&&_g.target(e)!=t;
-	  e = t < _g.target(e)?_left[e]:_right[e]) ;
+e = t < _g.target(e)?_left[e]:_right[e]) ;
 return e;
 }
 };
 ///Fast look up of all arcs between given endpoints.
 ///\ingroup gutils
 ///This class is the same as \ref ArcLookUp, with the addition
 ///that it makes it possible to find all arcs between given endpoints.
 ///
 ///\warning This class is static, so you should refresh() (or at least
 ///proportional (<em>O(m</em>log<em>m)</em>) to the number of arcs).
 ///
 ///\tparam G The type of the underlying digraph.
 ///
 ///\sa DynArcLookUp
 ///\sa ArcLookUp
 template<class G>
 class AllArcLookUp : public ArcLookUp<G>
 {
 using ArcLookUp<G>::_g;
 using ArcLookUp<G>::_right;
 using ArcLookUp<G>::_left;
 using ArcLookUp<G>::_head;
 TEMPLATE_DIGRAPH_TYPEDEFS(G);
 typedef G Digraph;
 typename Digraph::template ArcMap<Arc> _next;
 Arc refreshNext(Arc head,Arc next=INVALID)
 {
 if(head==INVALID) return next;
 else {
-	next=refreshNext(_right[head],next);
+next=refreshNext(_right[head],next);
-// 	_next[head]=next;
+//         _next[head]=next;
-	_next[head]=( next!=INVALID && _g.target(next)==_g.target(head))
+_next[head]=( next!=INVALID && _g.target(next)==_g.target(head))
-	  ? next : INVALID;
+? next : INVALID;
-	return refreshNext(_left[head],head);
+return refreshNext(_left[head],head);
 }
 }
 void refreshNext()
 {
 for(NodeIt n(_g);n!=INVALID;++n) refreshNext(_head[n]);
 }
 public:
 ///Constructor
 ///Constructor.
 ///
 ///Build up the search database of node \c n.
 ///
 ///It runs in time <em>O(d</em>log<em>d)</em>, where <em>d</em> is
 ///the number of the outgoing arcs of \c n.
 void refresh(Node n)
 {
 ArcLookUp<G>::refresh(n);
 refreshNext(_head[n]);
 }
 ///Refresh the full data structure.
 ///Build up the full search database. In fact, it simply calls
 ///\ref refresh(Node) "refresh(n)" for each node \c n.
 ///
 ///It runs in time <em>O(m</em>log<em>D)</em>, where <em>m</em> is
 ///the number of the arcs of \c n and <em>D</em> is the maximum
 ///out-degree of the digraph.
 void refresh()
 {
 for(NodeIt n(_g);n!=INVALID;++n) refresh(_head[n]);
 }
 ///Find an arc between two nodes.
 ///Find an arc between two nodes.
 ///\param s The source node
 ///\param t The target node
 ///\param prev The previous arc between \c s and \c t. It it is INVALID or
 ///not given, the operator finds the first appropriate arc.
 Arc operator()(Node s, Node t, Arc prev) const
 {
 return prev==INVALID?(*this)(s,t):_next[prev];
 }
 #endif
 };
 /// @}
 } //END OF NAMESPACE LEMON

changeset 211	542dd614cbb4
parent 199	e3aba2c72be4
child 212	1ae84dea7d09