list_graph.h

Go to the documentation of this file.
00001 /* -*- C++ -*- 00002 * src/lemon/list_graph.h - Part of LEMON, a generic C++ optimization library 00003 * 00004 * Copyright (C) 2004 Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport 00005 * (Egervary Combinatorial Optimization Research Group, EGRES). 00006 * 00007 * Permission to use, modify and distribute this software is granted 00008 * provided that this copyright notice appears in all copies. For 00009 * precise terms see the accompanying LICENSE file. 00010 * 00011 * This software is provided "AS IS" with no warranty of any kind, 00012 * express or implied, and with no claim as to its suitability for any 00013 * purpose. 00014 * 00015 */ 00016 00017 #ifndef LEMON_LIST_GRAPH_H 00018 #define LEMON_LIST_GRAPH_H 00019 00023 00024 #include <vector> 00025 #include <climits> 00026 00027 #include <lemon/invalid.h> 00028 00029 #include <lemon/map_registry.h> 00030 #include <lemon/array_map.h> 00031 00032 #include <lemon/sym_map.h> 00033 00034 #include <lemon/map_defines.h> 00035 00036 00037 namespace lemon { 00038 00041 00043 00049 class ListGraph { 00050 00051 //Nodes are double linked. 00052 //The free nodes are only single linked using the "next" field. 00053 struct NodeT 00054 { 00055 int first_in,first_out; 00056 int prev, next; 00057 }; 00058 //Edges are double linked. 00059 //The free edges are only single linked using the "next_in" field. 00060 struct EdgeT 00061 { 00062 int head, tail; 00063 int prev_in, prev_out; 00064 int next_in, next_out; 00065 }; 00066 00067 std::vector<NodeT> nodes; 00068 //The first node 00069 int first_node; 00070 //The first free node 00071 int first_free_node; 00072 std::vector<EdgeT> edges; 00073 //The first free edge 00074 int first_free_edge; 00075 00076 public: 00077 00078 typedef ListGraph Graph; 00079 00080 class Node; 00081 class Edge; 00082 00083 00084 public: 00085 00086 class NodeIt; 00087 class EdgeIt; 00088 class OutEdgeIt; 00089 class InEdgeIt; 00090 00091 // Create map registries. 00092 CREATE_MAP_REGISTRIES; 00093 // Create node and edge maps. 00094 CREATE_MAPS(ArrayMap); 00095 00096 public: 00097 00098 ListGraph() 00099 : nodes(), first_node(-1), 00100 first_free_node(-1), edges(), first_free_edge(-1) {} 00101 00102 ListGraph(const ListGraph &_g) 00103 : nodes(_g.nodes), first_node(_g.first_node), 00104 first_free_node(_g.first_free_node), edges(_g.edges), 00105 first_free_edge(_g.first_free_edge) {} 00106 00108 int nodeNum() const { return nodes.size(); } 00110 int edgeNum() const { return edges.size(); } 00111 00113 00117 void reserveEdge(int n) { edges.reserve(n); }; 00118 00120 00123 int maxNodeId() const { return nodes.size()-1; } 00125 00128 int maxEdgeId() const { return edges.size()-1; } 00129 00130 Node tail(Edge e) const { return edges[e.n].tail; } 00131 Node head(Edge e) const { return edges[e.n].head; } 00132 00133 NodeIt& first(NodeIt& v) const { 00134 v=NodeIt(*this); return v; } 00135 EdgeIt& first(EdgeIt& e) const { 00136 e=EdgeIt(*this); return e; } 00137 OutEdgeIt& first(OutEdgeIt& e, const Node v) const { 00138 e=OutEdgeIt(*this,v); return e; } 00139 InEdgeIt& first(InEdgeIt& e, const Node v) const { 00140 e=InEdgeIt(*this,v); return e; } 00141 00143 00150 static int id(Node v) { return v.n; } 00152 00159 static int id(Edge e) { return e.n; } 00160 00162 00165 Node addNode() { 00166 int n; 00167 00168 if(first_free_node==-1) 00169 { 00170 n = nodes.size(); 00171 nodes.push_back(NodeT()); 00172 } 00173 else { 00174 n = first_free_node; 00175 first_free_node = nodes[n].next; 00176 } 00177 00178 nodes[n].next = first_node; 00179 if(first_node != -1) nodes[first_node].prev = n; 00180 first_node = n; 00181 nodes[n].prev = -1; 00182 00183 nodes[n].first_in = nodes[n].first_out = -1; 00184 00185 Node nn; nn.n=n; 00186 00187 //Update dynamic maps 00188 node_maps.add(nn); 00189 00190 return nn; 00191 } 00192 00193 Edge addEdge(Node u, Node v) { 00194 int n; 00195 00196 if(first_free_edge==-1) 00197 { 00198 n = edges.size(); 00199 edges.push_back(EdgeT()); 00200 } 00201 else { 00202 n = first_free_edge; 00203 first_free_edge = edges[n].next_in; 00204 } 00205 00206 edges[n].tail = u.n; edges[n].head = v.n; 00207 00208 edges[n].next_out = nodes[u.n].first_out; 00209 if(nodes[u.n].first_out != -1) edges[nodes[u.n].first_out].prev_out = n; 00210 edges[n].next_in = nodes[v.n].first_in; 00211 if(nodes[v.n].first_in != -1) edges[nodes[v.n].first_in].prev_in = n; 00212 edges[n].prev_in = edges[n].prev_out = -1; 00213 00214 nodes[u.n].first_out = nodes[v.n].first_in = n; 00215 00216 Edge e; e.n=n; 00217 00218 //Update dynamic maps 00219 edge_maps.add(e); 00220 00221 return e; 00222 } 00223 00225 00232 Edge findEdge(Node u,Node v, Edge prev = INVALID) 00233 { 00234 int e = (prev.n==-1)? nodes[u.n].first_out : edges[prev.n].next_out; 00235 while(e!=-1 && edges[e].tail!=v.n) e = edges[e].next_out; 00236 prev.n=e; 00237 return prev; 00238 } 00239 00240 private: 00241 void eraseEdge(int n) { 00242 00243 if(edges[n].next_in!=-1) 00244 edges[edges[n].next_in].prev_in = edges[n].prev_in; 00245 if(edges[n].prev_in!=-1) 00246 edges[edges[n].prev_in].next_in = edges[n].next_in; 00247 else nodes[edges[n].head].first_in = edges[n].next_in; 00248 00249 if(edges[n].next_out!=-1) 00250 edges[edges[n].next_out].prev_out = edges[n].prev_out; 00251 if(edges[n].prev_out!=-1) 00252 edges[edges[n].prev_out].next_out = edges[n].next_out; 00253 else nodes[edges[n].tail].first_out = edges[n].next_out; 00254 00255 edges[n].next_in = first_free_edge; 00256 first_free_edge = n; 00257 00258 //Update dynamic maps 00259 Edge e; e.n=n; 00260 edge_maps.erase(e); 00261 00262 } 00263 00264 public: 00265 00266 void erase(Node nn) { 00267 int n=nn.n; 00268 00269 int m; 00270 while((m=nodes[n].first_in)!=-1) eraseEdge(m); 00271 while((m=nodes[n].first_out)!=-1) eraseEdge(m); 00272 00273 if(nodes[n].next != -1) nodes[nodes[n].next].prev = nodes[n].prev; 00274 if(nodes[n].prev != -1) nodes[nodes[n].prev].next = nodes[n].next; 00275 else first_node = nodes[n].next; 00276 00277 nodes[n].next = first_free_node; 00278 first_free_node = n; 00279 00280 //Update dynamic maps 00281 node_maps.erase(nn); 00282 00283 } 00284 00285 void erase(Edge e) { eraseEdge(e.n); } 00286 00287 void clear() { 00288 edge_maps.clear(); 00289 edges.clear(); 00290 node_maps.clear(); 00291 nodes.clear(); 00292 first_node=first_free_node=first_free_edge=-1; 00293 } 00294 00295 class Node { 00296 friend class ListGraph; 00297 template <typename T> friend class NodeMap; 00298 00299 friend class Edge; 00300 friend class OutEdgeIt; 00301 friend class InEdgeIt; 00302 friend class SymEdge; 00303 00304 protected: 00305 int n; 00306 friend int ListGraph::id(Node v); 00307 Node(int nn) {n=nn;} 00308 public: 00309 Node() {} 00310 Node (Invalid) { n=-1; } 00311 bool operator==(const Node i) const {return n==i.n;} 00312 bool operator!=(const Node i) const {return n!=i.n;} 00313 bool operator<(const Node i) const {return n<i.n;} 00314 // ///Validity check 00315 // operator bool() { return n!=-1; } 00316 }; 00317 00318 class NodeIt : public Node { 00319 const ListGraph *G; 00320 friend class ListGraph; 00321 public: 00322 NodeIt() : Node() { } 00323 NodeIt(Invalid i) : Node(i) { } 00324 NodeIt(const ListGraph& _G) : Node(_G.first_node), G(&_G) { } 00325 NodeIt(const ListGraph& _G,Node n) : Node(n), G(&_G) { } 00326 NodeIt &operator++() { 00327 n=G->nodes[n].next; 00328 return *this; 00329 } 00330 // ///Validity check 00331 // operator bool() { return Node::operator bool(); } 00332 }; 00333 00334 class Edge { 00335 friend class ListGraph; 00336 template <typename T> friend class EdgeMap; 00337 00338 friend class SymListGraph; 00339 00340 friend class Node; 00341 friend class NodeIt; 00342 protected: 00343 int n; 00344 friend int ListGraph::id(Edge e); 00345 00346 public: 00348 00351 Edge(int nn) {n=nn;} 00352 00353 Edge() { } 00354 Edge (Invalid) { n=-1; } 00355 bool operator==(const Edge i) const {return n==i.n;} 00356 bool operator!=(const Edge i) const {return n!=i.n;} 00357 bool operator<(const Edge i) const {return n<i.n;} 00358 // ///Validity check 00359 // operator bool() { return n!=-1; } 00360 }; 00361 00362 class EdgeIt : public Edge { 00363 const ListGraph *G; 00364 friend class ListGraph; 00365 public: 00366 EdgeIt(const ListGraph& _G) : Edge(), G(&_G) { 00367 int m; 00368 for(m=_G.first_node; 00369 m!=-1 && _G.nodes[m].first_in == -1; m = _G.nodes[m].next); 00370 n = (m==-1)?-1:_G.nodes[m].first_in; 00371 } 00372 EdgeIt (Invalid i) : Edge(i) { } 00373 EdgeIt(const ListGraph& _G, Edge e) : Edge(e), G(&_G) { } 00374 EdgeIt() : Edge() { } 00375 EdgeIt &operator++() { 00376 if(G->edges[n].next_in!=-1) n=G->edges[n].next_in; 00377 else { 00378 int nn; 00379 for(nn=G->nodes[G->edges[n].head].next; 00380 nn!=-1 && G->nodes[nn].first_in == -1; 00381 nn = G->nodes[nn].next) ; 00382 n = (nn==-1)?-1:G->nodes[nn].first_in; 00383 } 00384 return *this; 00385 } 00386 // ///Validity check 00387 // operator bool() { return Edge::operator bool(); } 00388 }; 00389 00390 class OutEdgeIt : public Edge { 00391 const ListGraph *G; 00392 friend class ListGraph; 00393 public: 00394 OutEdgeIt() : Edge() { } 00395 OutEdgeIt(const ListGraph& _G, Edge e) : Edge(e), G(&_G) { } 00396 OutEdgeIt (Invalid i) : Edge(i) { } 00397 00398 OutEdgeIt(const ListGraph& _G,const Node v) 00399 : Edge(_G.nodes[v.n].first_out), G(&_G) {} 00400 OutEdgeIt &operator++() { n=G->edges[n].next_out; return *this; } 00401 // ///Validity check 00402 // operator bool() { return Edge::operator bool(); } 00403 }; 00404 00405 class InEdgeIt : public Edge { 00406 const ListGraph *G; 00407 friend class ListGraph; 00408 public: 00409 InEdgeIt() : Edge() { } 00410 InEdgeIt(const ListGraph& _G, Edge e) : Edge(e), G(&_G) { } 00411 InEdgeIt (Invalid i) : Edge(i) { } 00412 InEdgeIt(const ListGraph& _G,Node v) 00413 : Edge(_G.nodes[v.n].first_in), G(&_G) { } 00414 InEdgeIt &operator++() { n=G->edges[n].next_in; return *this; } 00415 // ///Validity check 00416 // operator bool() { return Edge::operator bool(); } 00417 }; 00418 }; 00419 00421 00441 00442 class SymListGraph : public ListGraph 00443 { 00444 public: 00445 00446 typedef SymListGraph Graph; 00447 00448 // Create symmetric map registry. 00449 CREATE_SYM_EDGE_MAP_REGISTRY; 00450 // Create symmetric edge map. 00451 CREATE_SYM_EDGE_MAP(ArrayMap); 00452 00453 SymListGraph() : ListGraph() { } 00454 SymListGraph(const ListGraph &_g) : ListGraph(_g) { } 00456 Edge addEdge(Node u, Node v) 00457 { 00458 Edge e = ListGraph::addEdge(u,v); 00459 Edge f = ListGraph::addEdge(v,u); 00460 sym_edge_maps.add(e); 00461 sym_edge_maps.add(f); 00462 00463 return e; 00464 } 00465 00466 void erase(Node n) { ListGraph::erase(n);} 00468 00471 static Edge opposite(Edge e) 00472 { 00473 Edge f; 00474 f.n = e.n - 2*(e.n%2) + 1; 00475 return f; 00476 } 00477 00479 void erase(Edge e) { 00480 Edge f = opposite(e); 00481 sym_edge_maps.erase(e); 00482 sym_edge_maps.erase(f); 00483 ListGraph::erase(f); 00484 ListGraph::erase(e); 00485 } 00486 }; 00487 00488 00490 00502 class NodeSet { 00503 00504 //Nodes are double linked. 00505 //The free nodes are only single linked using the "next" field. 00506 struct NodeT 00507 { 00508 int first_in,first_out; 00509 int prev, next; 00510 // NodeT() {} 00511 }; 00512 00513 std::vector<NodeT> nodes; 00514 //The first node 00515 int first_node; 00516 //The first free node 00517 int first_free_node; 00518 00519 public: 00520 00521 typedef NodeSet Graph; 00522 00523 class Node; 00524 class Edge; 00525 00526 public: 00527 00528 class NodeIt; 00529 class EdgeIt; 00530 class OutEdgeIt; 00531 class InEdgeIt; 00532 00533 // Create node map registry. 00534 CREATE_NODE_MAP_REGISTRY; 00535 // Create node maps. 00536 CREATE_NODE_MAP(ArrayMap); 00537 00539 template <typename Value> 00540 class EdgeMap { 00541 public: 00542 EdgeMap(const Graph&) {} 00543 EdgeMap(const Graph&, const Value&) {} 00544 00545 EdgeMap(const EdgeMap&) {} 00546 template <typename CMap> EdgeMap(const CMap&) {} 00547 00548 EdgeMap& operator=(const EdgeMap&) {} 00549 template <typename CMap> EdgeMap& operator=(const CMap&) {} 00550 00551 class ConstIterator { 00552 public: 00553 bool operator==(const ConstIterator&) {return true;} 00554 bool operator!=(const ConstIterator&) {return false;} 00555 }; 00556 00557 typedef ConstIterator Iterator; 00558 00559 Iterator begin() { return Iterator();} 00560 Iterator end() { return Iterator();} 00561 00562 ConstIterator begin() const { return ConstIterator();} 00563 ConstIterator end() const { return ConstIterator();} 00564 00565 }; 00566 00567 public: 00568 00570 NodeSet() 00571 : nodes(), first_node(-1), first_free_node(-1) {} 00573 NodeSet(const NodeSet &_g) 00574 : nodes(_g.nodes), first_node(_g.first_node), 00575 first_free_node(_g.first_free_node) {} 00576 00578 int nodeNum() const { return nodes.size(); } 00580 int edgeNum() const { return 0; } 00581 00583 00586 int maxNodeId() const { return nodes.size()-1; } 00588 00591 int maxEdgeId() const { return 0; } 00592 00593 Node tail(Edge e) const { return INVALID; } 00594 Node head(Edge e) const { return INVALID; } 00595 00596 NodeIt& first(NodeIt& v) const { 00597 v=NodeIt(*this); return v; } 00598 EdgeIt& first(EdgeIt& e) const { 00599 e=EdgeIt(*this); return e; } 00600 OutEdgeIt& first(OutEdgeIt& e, const Node v) const { 00601 e=OutEdgeIt(*this,v); return e; } 00602 InEdgeIt& first(InEdgeIt& e, const Node v) const { 00603 e=InEdgeIt(*this,v); return e; } 00604 00606 00613 static int id(Node v) { return v.n; } 00615 00622 static int id(Edge e) { return -1; } 00623 00625 00628 Node addNode() { 00629 int n; 00630 00631 if(first_free_node==-1) 00632 { 00633 n = nodes.size(); 00634 nodes.push_back(NodeT()); 00635 } 00636 else { 00637 n = first_free_node; 00638 first_free_node = nodes[n].next; 00639 } 00640 00641 nodes[n].next = first_node; 00642 if(first_node != -1) nodes[first_node].prev = n; 00643 first_node = n; 00644 nodes[n].prev = -1; 00645 00646 nodes[n].first_in = nodes[n].first_out = -1; 00647 00648 Node nn; nn.n=n; 00649 00650 //Update dynamic maps 00651 node_maps.add(nn); 00652 00653 return nn; 00654 } 00655 00656 void erase(Node nn) { 00657 int n=nn.n; 00658 00659 if(nodes[n].next != -1) nodes[nodes[n].next].prev = nodes[n].prev; 00660 if(nodes[n].prev != -1) nodes[nodes[n].prev].next = nodes[n].next; 00661 else first_node = nodes[n].next; 00662 00663 nodes[n].next = first_free_node; 00664 first_free_node = n; 00665 00666 //Update dynamic maps 00667 node_maps.erase(nn); 00668 } 00669 00670 00671 Edge findEdge(Node u,Node v, Edge prev = INVALID) 00672 { 00673 return INVALID; 00674 } 00675 00676 void clear() { 00677 node_maps.clear(); 00678 nodes.clear(); 00679 first_node = first_free_node = -1; 00680 } 00681 00682 class Node { 00683 friend class NodeSet; 00684 template <typename T> friend class NodeMap; 00685 00686 friend class Edge; 00687 friend class OutEdgeIt; 00688 friend class InEdgeIt; 00689 00690 protected: 00691 int n; 00692 friend int NodeSet::id(Node v); 00693 Node(int nn) {n=nn;} 00694 public: 00695 Node() {} 00696 Node (Invalid i) { n=-1; } 00697 bool operator==(const Node i) const {return n==i.n;} 00698 bool operator!=(const Node i) const {return n!=i.n;} 00699 bool operator<(const Node i) const {return n<i.n;} 00700 }; 00701 00702 class NodeIt : public Node { 00703 const NodeSet *G; 00704 friend class NodeSet; 00705 public: 00706 NodeIt() : Node() { } 00707 NodeIt(const NodeSet& _G,Node n) : Node(n), G(&_G) { } 00708 NodeIt(Invalid i) : Node(i) { } 00709 NodeIt(const NodeSet& _G) : Node(_G.first_node), G(&_G) { } 00710 NodeIt &operator++() { 00711 n=G->nodes[n].next; 00712 return *this; 00713 } 00714 }; 00715 00716 class Edge { 00717 public: 00718 Edge() { } 00719 Edge (Invalid) { } 00720 bool operator==(const Edge i) const {return true;} 00721 bool operator!=(const Edge i) const {return false;} 00722 bool operator<(const Edge i) const {return false;} 00723 }; 00724 00725 class EdgeIt : public Edge { 00726 public: 00727 EdgeIt(const NodeSet& G) : Edge() { } 00728 EdgeIt(const NodeSet&, Edge) : Edge() { } 00729 EdgeIt (Invalid i) : Edge(i) { } 00730 EdgeIt() : Edge() { } 00731 EdgeIt operator++() { return INVALID; } 00732 }; 00733 00734 class OutEdgeIt : public Edge { 00735 friend class NodeSet; 00736 public: 00737 OutEdgeIt() : Edge() { } 00738 OutEdgeIt(const NodeSet&, Edge) : Edge() { } 00739 OutEdgeIt (Invalid i) : Edge(i) { } 00740 OutEdgeIt(const NodeSet& G,const Node v) : Edge() {} 00741 OutEdgeIt operator++() { return INVALID; } 00742 }; 00743 00744 class InEdgeIt : public Edge { 00745 friend class NodeSet; 00746 public: 00747 InEdgeIt() : Edge() { } 00748 InEdgeIt(const NodeSet&, Edge) : Edge() { } 00749 InEdgeIt (Invalid i) : Edge(i) { } 00750 InEdgeIt(const NodeSet& G,Node v) :Edge() {} 00751 InEdgeIt operator++() { return INVALID; } 00752 }; 00753 00754 }; 00755 00756 00757 00759 00779 template<typename GG> 00780 class EdgeSet { 00781 00782 typedef GG NodeGraphType; 00783 00784 NodeGraphType &G; 00785 00786 public: 00787 00788 class Node; 00789 class Edge; 00790 class OutEdgeIt; 00791 class InEdgeIt; 00792 class SymEdge; 00793 00794 typedef EdgeSet Graph; 00795 00796 int id(Node v) const; 00797 00798 class Node : public NodeGraphType::Node { 00799 friend class EdgeSet; 00800 00801 friend class Edge; 00802 friend class OutEdgeIt; 00803 friend class InEdgeIt; 00804 friend class SymEdge; 00805 00806 public: 00807 friend int EdgeSet::id(Node v) const; 00808 public: 00809 Node() : NodeGraphType::Node() {} 00810 Node (Invalid i) : NodeGraphType::Node(i) {} 00811 Node(const typename NodeGraphType::Node &n) : NodeGraphType::Node(n) {} 00812 }; 00813 00814 class NodeIt : public NodeGraphType::NodeIt { 00815 friend class EdgeSet; 00816 public: 00817 NodeIt() : NodeGraphType::NodeIt() { } 00818 NodeIt(const EdgeSet& _G,Node n) : NodeGraphType::NodeIt(_G.G,n) { } 00819 NodeIt (Invalid i) : NodeGraphType::NodeIt(i) {} 00820 NodeIt(const EdgeSet& _G) : NodeGraphType::NodeIt(_G.G) { } 00821 NodeIt(const typename NodeGraphType::NodeIt &n) 00822 : NodeGraphType::NodeIt(n) {} 00823 00824 operator Node() { return Node(*this);} 00825 NodeIt &operator++() 00826 { this->NodeGraphType::NodeIt::operator++(); return *this;} 00827 }; 00828 00829 private: 00830 //Edges are double linked. 00831 //The free edges are only single linked using the "next_in" field. 00832 struct NodeT 00833 { 00834 int first_in,first_out; 00835 NodeT() : first_in(-1), first_out(-1) { } 00836 }; 00837 00838 struct EdgeT 00839 { 00840 Node head, tail; 00841 int prev_in, prev_out; 00842 int next_in, next_out; 00843 }; 00844 00845 00846 typename NodeGraphType::template NodeMap<NodeT> nodes; 00847 00848 std::vector<EdgeT> edges; 00849 //The first free edge 00850 int first_free_edge; 00851 00852 public: 00853 00854 class Node; 00855 class Edge; 00856 00857 class NodeIt; 00858 class EdgeIt; 00859 class OutEdgeIt; 00860 class InEdgeIt; 00861 00862 00863 // Create edge map registry. 00864 CREATE_EDGE_MAP_REGISTRY; 00865 // Create edge maps. 00866 CREATE_EDGE_MAP(ArrayMap); 00867 00868 // Import node maps from the NodeGraphType. 00869 IMPORT_NODE_MAP(NodeGraphType, graph.G, EdgeSet, graph); 00870 00871 00872 public: 00873 00875 00878 explicit EdgeSet(NodeGraphType &_G) 00879 : G(_G), nodes(_G), edges(), 00880 first_free_edge(-1) {} 00882 00885 explicit EdgeSet(const EdgeSet &_g) 00886 : G(_g.G), nodes(_g.G), edges(_g.edges), 00887 first_free_edge(_g.first_free_edge) {} 00888 00890 int nodeNum() const { return G.nodeNum(); } 00892 int edgeNum() const { return edges.size(); } 00893 00895 00898 int maxNodeId() const { return G.maxNodeId(); } 00900 00903 int maxEdgeId() const { return edges.size()-1; } 00904 00905 Node tail(Edge e) const { return edges[e.n].tail; } 00906 Node head(Edge e) const { return edges[e.n].head; } 00907 00908 NodeIt& first(NodeIt& v) const { 00909 v=NodeIt(*this); return v; } 00910 EdgeIt& first(EdgeIt& e) const { 00911 e=EdgeIt(*this); return e; } 00912 OutEdgeIt& first(OutEdgeIt& e, const Node v) const { 00913 e=OutEdgeIt(*this,v); return e; } 00914 InEdgeIt& first(InEdgeIt& e, const Node v) const { 00915 e=InEdgeIt(*this,v); return e; } 00916 00918 00925 int id(Node v) { return G.id(v); } 00927 00934 static int id(Edge e) { return e.n; } 00935 00937 Node addNode() { return G.addNode(); } 00938 00939 Edge addEdge(Node u, Node v) { 00940 int n; 00941 00942 if(first_free_edge==-1) 00943 { 00944 n = edges.size(); 00945 edges.push_back(EdgeT()); 00946 } 00947 else { 00948 n = first_free_edge; 00949 first_free_edge = edges[n].next_in; 00950 } 00951 00952 edges[n].tail = u; edges[n].head = v; 00953 00954 edges[n].next_out = nodes[u].first_out; 00955 if(nodes[u].first_out != -1) edges[nodes[u].first_out].prev_out = n; 00956 edges[n].next_in = nodes[v].first_in; 00957 if(nodes[v].first_in != -1) edges[nodes[v].first_in].prev_in = n; 00958 edges[n].prev_in = edges[n].prev_out = -1; 00959 00960 nodes[u].first_out = nodes[v].first_in = n; 00961 00962 Edge e; e.n=n; 00963 00964 //Update dynamic maps 00965 edge_maps.add(e); 00966 00967 return e; 00968 } 00969 00971 00978 Edge findEdge(Node u,Node v, Edge prev = INVALID) 00979 { 00980 int e = (prev.n==-1)? nodes[u].first_out : edges[prev.n].next_out; 00981 while(e!=-1 && edges[e].tail!=v) e = edges[e].next_out; 00982 prev.n=e; 00983 return prev; 00984 } 00985 00986 private: 00987 void eraseEdge(int n) { 00988 00989 if(edges[n].next_in!=-1) 00990 edges[edges[n].next_in].prev_in = edges[n].prev_in; 00991 if(edges[n].prev_in!=-1) 00992 edges[edges[n].prev_in].next_in = edges[n].next_in; 00993 else nodes[edges[n].head].first_in = edges[n].next_in; 00994 00995 if(edges[n].next_out!=-1) 00996 edges[edges[n].next_out].prev_out = edges[n].prev_out; 00997 if(edges[n].prev_out!=-1) 00998 edges[edges[n].prev_out].next_out = edges[n].next_out; 00999 else nodes[edges[n].tail].first_out = edges[n].next_out; 01000 01001 edges[n].next_in = first_free_edge; 01002 first_free_edge = -1; 01003 01004 //Update dynamic maps 01005 Edge e; e.n = n; 01006 edge_maps.erase(e); 01007 } 01008 01009 public: 01010 01011 void erase(Edge e) { eraseEdge(e.n); } 01012 01014 void clear() { 01015 edge_maps.clear(); 01016 edges.clear(); 01017 first_free_edge=-1; 01018 } 01019 01020 01021 class Edge { 01022 public: 01023 friend class EdgeSet; 01024 template <typename T> friend class EdgeMap; 01025 01026 friend class Node; 01027 friend class NodeIt; 01028 protected: 01029 int n; 01030 friend int EdgeSet::id(Edge e) const; 01031 01032 Edge(int nn) {n=nn;} 01033 public: 01034 Edge() { } 01035 Edge (Invalid) { n=-1; } 01036 bool operator==(const Edge i) const {return n==i.n;} 01037 bool operator!=(const Edge i) const {return n!=i.n;} 01038 bool operator<(const Edge i) const {return n<i.n;} 01039 }; 01040 01041 class EdgeIt : public Edge { 01042 friend class EdgeSet; 01043 template <typename T> friend class EdgeMap; 01044 01045 const EdgeSet *G; 01046 public: 01047 EdgeIt(const EdgeSet& _G) : Edge(), G(&_G) { 01048 NodeIt m; 01049 for(G->first(m); 01050 m!=INVALID && G->nodes[m].first_in == -1; ++m); 01052 this->n = m!=INVALID?-1:G->nodes[m].first_in; 01053 } 01054 EdgeIt(const EdgeSet& _G, Edge e) : Edge(e), G(&_G) { } 01055 EdgeIt (Invalid i) : Edge(i) { } 01056 EdgeIt() : Edge() { } 01058 01060 // 01061 EdgeIt &operator++() { 01062 return *this; 01063 } 01064 }; 01065 01066 class OutEdgeIt : public Edge { 01067 const EdgeSet *G; 01068 friend class EdgeSet; 01069 public: 01070 OutEdgeIt() : Edge() { } 01071 OutEdgeIt (Invalid i) : Edge(i) { } 01072 OutEdgeIt(const EdgeSet& _G, Edge e) : Edge(e), G(&_G) { } 01073 01074 OutEdgeIt(const EdgeSet& _G,const Node v) : 01075 Edge(_G.nodes[v].first_out), G(&_G) { } 01076 OutEdgeIt &operator++() { 01077 Edge::n = G->edges[Edge::n].next_out; 01078 return *this; 01079 } 01080 }; 01081 01082 class InEdgeIt : public Edge { 01083 const EdgeSet *G; 01084 friend class EdgeSet; 01085 public: 01086 InEdgeIt() : Edge() { } 01087 InEdgeIt (Invalid i) : Edge(i) { } 01088 InEdgeIt(const EdgeSet& _G, Edge e) : Edge(e), G(&_G) { } 01089 InEdgeIt(const EdgeSet& _G,Node v) 01090 : Edge(_G.nodes[v].first_in), G(&_G) { } 01091 InEdgeIt &operator++() { 01092 Edge::n = G->edges[Edge::n].next_in; 01093 return *this; 01094 } 01095 }; 01096 01097 }; 01098 01099 template<typename GG> 01100 inline int EdgeSet<GG>::id(Node v) const { return G.id(v); } 01101 01103 01104 } //namespace lemon 01105 01106 #endif //LEMON_LIST_GRAPH_H

Generated on Thu Sep 30 12:18:33 2004 for LEMON by doxygen 1.3.8