00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
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
00052
00053
struct NodeT
00054 {
00055
int first_in,first_out;
00056
int prev, next;
00057 };
00058
00059
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
00069
int first_node;
00070
00071
int first_free_node;
00072 std::vector<EdgeT> edges;
00073
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
00092 CREATE_MAP_REGISTRIES;
00093
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
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
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
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
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
00315
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
00331
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
00359
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
00387
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
00402
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
00416
00417 };
00418 };
00419
00421
00441
00442 class SymListGraph :
public ListGraph
00443 {
00444
public:
00445
00446
typedef SymListGraph Graph;
00447
00448
00449 CREATE_SYM_EDGE_MAP_REGISTRY;
00450
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
00505
00506
struct NodeT
00507 {
00508
int first_in,first_out;
00509
int prev, next;
00510
00511 };
00512
00513 std::vector<NodeT> nodes;
00514
00515
int first_node;
00516
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
00534 CREATE_NODE_MAP_REGISTRY;
00535
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
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
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
00831
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
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
00864
CREATE_EDGE_MAP_REGISTRY;
00865
00866
CREATE_EDGE_MAP(
ArrayMap);
00867
00868
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
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
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 }
01105
01106
#endif //LEMON_LIST_GRAPH_H