[Lemon-commits] [lemon_svn] alpar: r1052 - hugo/branches/hugo++/src/hugo
Lemon SVN
svn at lemon.cs.elte.hu
Mon Nov 6 20:42:58 CET 2006
Author: alpar
Date: Fri Aug 27 16:36:31 2004
New Revision: 1052
Modified:
hugo/branches/hugo++/src/hugo/max_flow.h
Log:
New style operators. Untested.
Modified: hugo/branches/hugo++/src/hugo/max_flow.h
==============================================================================
--- hugo/branches/hugo++/src/hugo/max_flow.h (original)
+++ hugo/branches/hugo++/src/hugo/max_flow.h Fri Aug 27 16:36:31 2004
@@ -112,27 +112,27 @@
/// Do not needle this flag only if necessary.
StatusEnum status;
-// int number_of_augmentations;
+ // int number_of_augmentations;
-// template<typename IntMap>
-// class TrickyReachedMap {
-// protected:
-// IntMap* map;
-// int* number_of_augmentations;
-// public:
-// TrickyReachedMap(IntMap& _map, int& _number_of_augmentations) :
-// map(&_map), number_of_augmentations(&_number_of_augmentations) { }
-// void set(const Node& n, bool b) {
-// if (b)
-// map->set(n, *number_of_augmentations);
-// else
-// map->set(n, *number_of_augmentations-1);
-// }
-// bool operator[](const Node& n) const {
-// return (*map)[n]==*number_of_augmentations;
-// }
-// };
+ // template<typename IntMap>
+ // class TrickyReachedMap {
+ // protected:
+ // IntMap* map;
+ // int* number_of_augmentations;
+ // public:
+ // TrickyReachedMap(IntMap& _map, int& _number_of_augmentations) :
+ // map(&_map), number_of_augmentations(&_number_of_augmentations) { }
+ // void set(const Node& n, bool b) {
+ // if (b)
+ // map->set(n, *number_of_augmentations);
+ // else
+ // map->set(n, *number_of_augmentations-1);
+ // }
+ // bool operator[](const Node& n) const {
+ // return (*map)[n]==*number_of_augmentations;
+ // }
+ // };
///Constructor
@@ -234,7 +234,7 @@
} else break;
}
- if ( !g->valid(first[b]) ) --b;
+ if ( first[b]==INVALID ) --b;
else {
end=false;
Node w=first[b];
@@ -289,8 +289,7 @@
bfs_queue.pop();
int l=level[v]+1;
- InEdgeIt e;
- for(g->first(e,v); g->valid(e); g->next(e)) {
+ for(InEdgeIt e(*g,v); e!=INVALID; ++e) {
if ( (*capacity)[e] <= (*flow)[e] ) continue;
Node u=g->tail(e);
if ( level[u] >= n ) {
@@ -303,10 +302,9 @@
}
}
- OutEdgeIt f;
- for(g->first(f,v); g->valid(f); g->next(f)) {
- if ( 0 >= (*flow)[f] ) continue;
- Node u=g->head(f);
+ for(OutEdgeIt e(*g,v); e!=INVALID; ++e) {
+ if ( 0 >= (*flow)[e] ) continue;
+ Node u=g->head(e);
if ( level[u] >= n ) {
bfs_queue.push(u);
level.set(u, l);
@@ -323,7 +321,7 @@
if ( b == 0 ) break;
- if ( !g->valid(first[b]) ) --b;
+ if ( first[b]==INVALID ) --b;
else {
Node w=first[b];
@@ -351,10 +349,10 @@
/// the maximum flow.
/// It can be called already after running \ref preflowPhase1.
Num flowValue() const {
-// Num a=0;
-// for(InEdgeIt e(*g,t);g->valid(e);g->next(e)) a+=(*flow)[e];
-// for(OutEdgeIt e(*g,t);g->valid(e);g->next(e)) a-=(*flow)[e];
-// return a;
+ // Num a=0;
+ // for(InEdgeIt e(*g,t);g->valid(e);g->next(e)) a+=(*flow)[e];
+ // for(OutEdgeIt e(*g,t);g->valid(e);g->next(e)) a-=(*flow)[e];
+ // return a;
return excess[t];
//marci figyu: excess[t] epp ezt adja preflow 1. fazisa utan
}
@@ -374,10 +372,9 @@
/// for MinCut computation
template<typename _CutMap>
void actMinCut(_CutMap& M) const {
- NodeIt v;
switch (status) {
- case AFTER_PRE_FLOW_PHASE_1:
- for(g->first(v); g->valid(v); g->next(v)) {
+ case AFTER_PRE_FLOW_PHASE_1:
+ for(NodeIt v(*g); v!=INVALID; ++v) {
if (level[v] < n) {
M.set(v, false);
} else {
@@ -385,10 +382,10 @@
}
}
break;
- case AFTER_PRE_FLOW_PHASE_2:
- case AFTER_NOTHING:
- case AFTER_AUGMENTING:
- case AFTER_FAST_AUGMENTING:
+ case AFTER_PRE_FLOW_PHASE_2:
+ case AFTER_NOTHING:
+ case AFTER_AUGMENTING:
+ case AFTER_FAST_AUGMENTING:
minMinCut(M);
break;
}
@@ -412,8 +409,7 @@
Node w=queue.front();
queue.pop();
- OutEdgeIt e;
- for(g->first(e,w) ; g->valid(e); g->next(e)) {
+ for(OutEdgeIt e(*g,w) ; e!=INVALID; ++e) {
Node v=g->head(e);
if (!M[v] && (*flow)[e] < (*capacity)[e] ) {
queue.push(v);
@@ -421,10 +417,9 @@
}
}
- InEdgeIt f;
- for(g->first(f,w) ; g->valid(f); g->next(f)) {
- Node v=g->tail(f);
- if (!M[v] && (*flow)[f] > 0 ) {
+ for(InEdgeIt e(*g,w) ; e!=INVALID; ++e) {
+ Node v=g->tail(e);
+ if (!M[v] && (*flow)[e] > 0 ) {
queue.push(v);
M.set(v, true);
}
@@ -442,10 +437,7 @@
template<typename _CutMap>
void maxMinCut(_CutMap& M) const {
- NodeIt v;
- for(g->first(v) ; g->valid(v); g->next(v)) {
- M.set(v, true);
- }
+ for(NodeIt v(*g) ; v!=INVALID; ++v) M.set(v, true);
std::queue<Node> queue;
@@ -456,8 +448,7 @@
Node w=queue.front();
queue.pop();
- InEdgeIt e;
- for(g->first(e,w) ; g->valid(e); g->next(e)) {
+ for(InEdgeIt e(*g,w) ; e!=INVALID; ++e) {
Node v=g->tail(e);
if (M[v] && (*flow)[e] < (*capacity)[e] ) {
queue.push(v);
@@ -465,10 +456,9 @@
}
}
- OutEdgeIt f;
- for(g->first(f,w) ; g->valid(f); g->next(f)) {
- Node v=g->head(f);
- if (M[v] && (*flow)[f] > 0 ) {
+ for(OutEdgeIt e(*g,w) ; e!=INVALID; ++e) {
+ Node v=g->head(e);
+ if (M[v] && (*flow)[e] > 0 ) {
queue.push(v);
M.set(v, false);
}
@@ -518,14 +508,12 @@
Num exc=excess[w];
int newlevel=n; //bound on the next level of w
- OutEdgeIt e;
- for(g->first(e,w); g->valid(e); g->next(e)) {
-
+ for(OutEdgeIt e(*g,w) ; e!=INVALID; ++e) {
if ( (*flow)[e] >= (*capacity)[e] ) continue;
Node v=g->head(e);
if( lev > level[v] ) { //Push is allowed now
-
+
if ( excess[v]<=0 && v!=t && v!=s ) {
next.set(v,first[level[v]]);
first[level[v]]=v;
@@ -534,9 +522,9 @@
Num cap=(*capacity)[e];
Num flo=(*flow)[e];
Num remcap=cap-flo;
-
+
if ( remcap >= exc ) { //A nonsaturating push.
-
+
flow->set(e, flo+exc);
excess.set(v, excess[v]+exc);
exc=0;
@@ -551,9 +539,8 @@
} //for out edges wv
if ( exc > 0 ) {
- InEdgeIt e;
- for(g->first(e,w); g->valid(e); g->next(e)) {
-
+ for(InEdgeIt e(*g,w) ; e!=INVALID; ++e) {
+
if( (*flow)[e] <= 0 ) continue;
Node v=g->tail(e);
@@ -584,49 +571,36 @@
} // if w still has excess after the out edge for cycle
excess.set(w, exc);
-
+
return newlevel;
}
-
-
-
+
+
+
void preflowPreproc(FlowEnum fe, NNMap& next, VecFirst& first,
VecNode& level_list, NNMap& left, NNMap& right)
{
- switch (fe) { //setting excess
+ switch (fe) { //setting excess
case NO_FLOW:
- {
- EdgeIt e;
- for(g->first(e); g->valid(e); g->next(e)) flow->set(e,0);
-
- NodeIt v;
- for(g->first(v); g->valid(v); g->next(v)) excess.set(v,0);
- break;
- }
+ for(EdgeIt e(*g); e!=INVALID; ++e) flow->set(e,0);
+ for(NodeIt v(*g); v!=INVALID; ++v) excess.set(v,0);
+ break;
case ZERO_FLOW:
- {
- NodeIt v;
- for(g->first(v); g->valid(v); g->next(v)) excess.set(v,0);
- break;
- }
+ for(NodeIt v(*g); v!=INVALID; ++v) excess.set(v,0);
+ break;
case GEN_FLOW:
- {
- NodeIt v;
- for(g->first(v); g->valid(v); g->next(v)) excess.set(v,0);
+ for(NodeIt v(*g); v!=INVALID; ++v) excess.set(v,0);
- Num exc=0;
- InEdgeIt e;
- for(g->first(e,t); g->valid(e); g->next(e)) exc+=(*flow)[e];
- OutEdgeIt f;
- for(g->first(f,t); g->valid(f); g->next(f)) exc-=(*flow)[f];
- excess.set(t,exc);
- break;
- }
- default: break;
+ Num exc=0;
+ for(InEdgeIt e(*g,t) ; e!=INVALID; ++e) exc+=(*flow)[e];
+ for(OutEdgeIt e(*g,t) ; e!=INVALID; ++e) exc-=(*flow)[e];
+ excess.set(t,exc);
+ break;
+ default:
+ break;
}
-
- NodeIt v;
- for(g->first(v); g->valid(v); g->next(v)) level.set(v,n);
+
+ for(NodeIt v(*g); v!=INVALID; ++v) level.set(v,n);
//setting each node to level n
std::queue<Node> bfs_queue;
@@ -635,217 +609,195 @@
switch (fe) {
case NO_FLOW: //flow is already set to const zero
case ZERO_FLOW:
- {
- //Reverse_bfs from t, to find the starting level.
- level.set(t,0);
- bfs_queue.push(t);
-
- while (!bfs_queue.empty()) {
-
- Node v=bfs_queue.front();
- bfs_queue.pop();
- int l=level[v]+1;
-
- InEdgeIt e;
- for(g->first(e,v); g->valid(e); g->next(e)) {
- Node w=g->tail(e);
- if ( level[w] == n && w != s ) {
- bfs_queue.push(w);
- Node z=level_list[l];
- if ( g->valid(z) ) left.set(z,w);
- right.set(w,z);
- level_list[l]=w;
- level.set(w, l);
- }
+ //Reverse_bfs from t, to find the starting level.
+ level.set(t,0);
+ bfs_queue.push(t);
+
+ while (!bfs_queue.empty()) {
+
+ Node v=bfs_queue.front();
+ bfs_queue.pop();
+ int l=level[v]+1;
+
+ for(InEdgeIt e(*g,v) ; e!=INVALID; ++e) {
+ Node w=g->tail(e);
+ if ( level[w] == n && w != s ) {
+ bfs_queue.push(w);
+ Node z=level_list[l];
+ if ( z!=INVALID ) left.set(z,w);
+ right.set(w,z);
+ level_list[l]=w;
+ level.set(w, l);
}
}
-
- //the starting flow
- OutEdgeIt e;
- for(g->first(e,s); g->valid(e); g->next(e))
- {
- Num c=(*capacity)[e];
- if ( c <= 0 ) continue;
- Node w=g->head(e);
- if ( level[w] < n ) {
- if ( excess[w] <= 0 && w!=t ) //putting into the stack
- {
- next.set(w,first[level[w]]);
- first[level[w]]=w;
- }
- flow->set(e, c);
- excess.set(w, excess[w]+c);
- }
- }
- break;
}
-
+
+ //the starting flow
+ for(OutEdgeIt e(*g,s) ; e!=INVALID; ++e)
+ {
+ Num c=(*capacity)[e];
+ if ( c <= 0 ) continue;
+ Node w=g->head(e);
+ if ( level[w] < n ) {
+ if ( excess[w] <= 0 && w!=t ) //putting into the stack
+ {
+ next.set(w,first[level[w]]);
+ first[level[w]]=w;
+ }
+ flow->set(e, c);
+ excess.set(w, excess[w]+c);
+ }
+ }
+ break;
case GEN_FLOW:
- {
- //Reverse_bfs from t in the residual graph,
- //to find the starting level.
- level.set(t,0);
- bfs_queue.push(t);
-
- while (!bfs_queue.empty()) {
-
- Node v=bfs_queue.front();
- bfs_queue.pop();
- int l=level[v]+1;
-
- InEdgeIt e;
- for(g->first(e,v); g->valid(e); g->next(e)) {
- if ( (*capacity)[e] <= (*flow)[e] ) continue;
- Node w=g->tail(e);
- if ( level[w] == n && w != s ) {
- bfs_queue.push(w);
- Node z=level_list[l];
- if ( g->valid(z) ) left.set(z,w);
- right.set(w,z);
- level_list[l]=w;
- level.set(w, l);
- }
- }
-
- OutEdgeIt f;
- for(g->first(f,v); g->valid(f); g->next(f)) {
- if ( 0 >= (*flow)[f] ) continue;
- Node w=g->head(f);
- if ( level[w] == n && w != s ) {
- bfs_queue.push(w);
- Node z=level_list[l];
- if ( g->valid(z) ) left.set(z,w);
- right.set(w,z);
- level_list[l]=w;
- level.set(w, l);
- }
+ //Reverse_bfs from t in the residual graph,
+ //to find the starting level.
+ level.set(t,0);
+ bfs_queue.push(t);
+
+ while (!bfs_queue.empty()) {
+
+ Node v=bfs_queue.front();
+ bfs_queue.pop();
+ int l=level[v]+1;
+
+ for(InEdgeIt e(*g,v) ; e!=INVALID; ++e) {
+ if ( (*capacity)[e] <= (*flow)[e] ) continue;
+ Node w=g->tail(e);
+ if ( level[w] == n && w != s ) {
+ bfs_queue.push(w);
+ Node z=level_list[l];
+ if ( z!=INVALID ) left.set(z,w);
+ right.set(w,z);
+ level_list[l]=w;
+ level.set(w, l);
}
}
-
- //the starting flow
- OutEdgeIt e;
- for(g->first(e,s); g->valid(e); g->next(e))
- {
- Num rem=(*capacity)[e]-(*flow)[e];
- if ( rem <= 0 ) continue;
- Node w=g->head(e);
- if ( level[w] < n ) {
- if ( excess[w] <= 0 && w!=t ) //putting into the stack
- {
- next.set(w,first[level[w]]);
- first[level[w]]=w;
- }
- flow->set(e, (*capacity)[e]);
- excess.set(w, excess[w]+rem);
- }
+
+ for(OutEdgeIt e(*g,v) ; e!=INVALID; ++e) {
+ if ( 0 >= (*flow)[e] ) continue;
+ Node w=g->head(e);
+ if ( level[w] == n && w != s ) {
+ bfs_queue.push(w);
+ Node z=level_list[l];
+ if ( z!=INVALID ) left.set(z,w);
+ right.set(w,z);
+ level_list[l]=w;
+ level.set(w, l);
}
-
- InEdgeIt f;
- for(g->first(f,s); g->valid(f); g->next(f))
- {
- if ( (*flow)[f] <= 0 ) continue;
- Node w=g->tail(f);
- if ( level[w] < n ) {
- if ( excess[w] <= 0 && w!=t )
- {
- next.set(w,first[level[w]]);
- first[level[w]]=w;
- }
- excess.set(w, excess[w]+(*flow)[f]);
- flow->set(f, 0);
- }
+ }
+ }
+
+ //the starting flow
+ for(OutEdgeIt e(*g,s); e!=INVALID; ++e)
+ {
+ Num rem=(*capacity)[e]-(*flow)[e];
+ if ( rem <= 0 ) continue;
+ Node w=g->head(e);
+ if ( level[w] < n ) {
+ if ( excess[w] <= 0 && w!=t ) //putting into the stack
+ {
+ next.set(w,first[level[w]]);
+ first[level[w]]=w;
+ }
+ flow->set(e, (*capacity)[e]);
+ excess.set(w, excess[w]+rem);
+ }
+ }
+
+ for(InEdgeIt e(*g,s); e!=INVALID; ++e)
+ {
+ if ( (*flow)[e] <= 0 ) continue;
+ Node w=g->tail(e);
+ if ( level[w] < n ) {
+ if ( excess[w] <= 0 && w!=t )
+ {
+ next.set(w,first[level[w]]);
+ first[level[w]]=w;
+ }
+ excess.set(w, excess[w]+(*flow)[e]);
+ flow->set(e, 0);
}
- break;
- } //case GEN_FLOW
-
+ }
+ break;
case PRE_FLOW:
- {
- //Reverse_bfs from t in the residual graph,
- //to find the starting level.
- level.set(t,0);
- bfs_queue.push(t);
-
- while (!bfs_queue.empty()) {
-
- Node v=bfs_queue.front();
- bfs_queue.pop();
- int l=level[v]+1;
-
- InEdgeIt e;
- for(g->first(e,v); g->valid(e); g->next(e)) {
- if ( (*capacity)[e] <= (*flow)[e] ) continue;
- Node w=g->tail(e);
- if ( level[w] == n && w != s ) {
- bfs_queue.push(w);
- Node z=level_list[l];
- if ( g->valid(z) ) left.set(z,w);
- right.set(w,z);
- level_list[l]=w;
- level.set(w, l);
- }
- }
-
- OutEdgeIt f;
- for(g->first(f,v); g->valid(f); g->next(f)) {
- if ( 0 >= (*flow)[f] ) continue;
- Node w=g->head(f);
- if ( level[w] == n && w != s ) {
- bfs_queue.push(w);
- Node z=level_list[l];
- if ( g->valid(z) ) left.set(z,w);
- right.set(w,z);
- level_list[l]=w;
- level.set(w, l);
- }
+ //Reverse_bfs from t in the residual graph,
+ //to find the starting level.
+ level.set(t,0);
+ bfs_queue.push(t);
+
+ while (!bfs_queue.empty()) {
+
+ Node v=bfs_queue.front();
+ bfs_queue.pop();
+ int l=level[v]+1;
+
+ for(InEdgeIt e(*g,v) ; e!=INVALID; ++e) {
+ if ( (*capacity)[e] <= (*flow)[e] ) continue;
+ Node w=g->tail(e);
+ if ( level[w] == n && w != s ) {
+ bfs_queue.push(w);
+ Node z=level_list[l];
+ if ( z!=INVALID ) left.set(z,w);
+ right.set(w,z);
+ level_list[l]=w;
+ level.set(w, l);
}
}
-
-
- //the starting flow
- OutEdgeIt e;
- for(g->first(e,s); g->valid(e); g->next(e))
- {
- Num rem=(*capacity)[e]-(*flow)[e];
- if ( rem <= 0 ) continue;
- Node w=g->head(e);
- if ( level[w] < n ) {
- flow->set(e, (*capacity)[e]);
- excess.set(w, excess[w]+rem);
- }
+
+ for(OutEdgeIt e(*g,v) ; e!=INVALID; ++e) {
+ if ( 0 >= (*flow)[e] ) continue;
+ Node w=g->head(e);
+ if ( level[w] == n && w != s ) {
+ bfs_queue.push(w);
+ Node z=level_list[l];
+ if ( z!=INVALID ) left.set(z,w);
+ right.set(w,z);
+ level_list[l]=w;
+ level.set(w, l);
}
-
- InEdgeIt f;
- for(g->first(f,s); g->valid(f); g->next(f))
- {
- if ( (*flow)[f] <= 0 ) continue;
- Node w=g->tail(f);
- if ( level[w] < n ) {
- excess.set(w, excess[w]+(*flow)[f]);
- flow->set(f, 0);
- }
- }
-
- NodeIt w; //computing the excess
- for(g->first(w); g->valid(w); g->next(w)) {
- Num exc=0;
-
- InEdgeIt e;
- for(g->first(e,w); g->valid(e); g->next(e)) exc+=(*flow)[e];
- OutEdgeIt f;
- for(g->first(f,w); g->valid(f); g->next(f)) exc-=(*flow)[f];
-
- excess.set(w,exc);
-
- //putting the active nodes into the stack
- int lev=level[w];
- if ( exc > 0 && lev < n && w != t )
- {
- next.set(w,first[lev]);
- first[lev]=w;
- }
}
- break;
- } //case PRE_FLOW
+ }
+
+
+ //the starting flow
+ for(OutEdgeIt e(*g,s) ; e!=INVALID; ++e) {
+ Num rem=(*capacity)[e]-(*flow)[e];
+ if ( rem <= 0 ) continue;
+ Node w=g->head(e);
+ if ( level[w] < n ) {
+ flow->set(e, (*capacity)[e]);
+ excess.set(w, excess[w]+rem);
+ }
+ }
+
+ for(InEdgeIt e(*g,s) ; e!=INVALID; ++e) {
+ if ( (*flow)[e] <= 0 ) continue;
+ Node w=g->tail(e);
+ if ( level[w] < n ) {
+ excess.set(w, excess[w]+(*flow)[e]);
+ flow->set(e, 0);
+ }
+ }
+
+ //computing the excess
+ for(NodeIt w(*g); w!=INVALID; ++w) {
+ Num exc=0;
+
+ for(InEdgeIt e(*g,w) ; e!=INVALID; ++e) exc+=(*flow)[e];
+ for(OutEdgeIt e(*g,w) ; e!=INVALID; ++e) exc-=(*flow)[e];
+
+ excess.set(w,exc);
+
+ //putting the active nodes into the stack
+ int lev=level[w];
+ if ( exc > 0 && lev < n && w != t )
+ {
+ next.set(w,first[lev]);
+ first[lev]=w;
+ }
+ }
+ break;
}
} //preflowPreproc
@@ -861,8 +813,8 @@
Node left_n=left[w];
//unlacing starts
- if ( g->valid(right_n) ) {
- if ( g->valid(left_n) ) {
+ if ( right_n!=INVALID ) {
+ if ( left_n!=INVALID ) {
right.set(left_n, right_n);
left.set(right_n, left_n);
} else {
@@ -870,7 +822,7 @@
left.set(right_n, INVALID);
}
} else {
- if ( g->valid(left_n) ) {
+ if ( left_n!=INVALID ) {
right.set(left_n, INVALID);
} else {
level_list[lev]=INVALID;
@@ -878,12 +830,12 @@
}
//unlacing ends
- if ( !g->valid(level_list[lev]) ) {
+ if ( level_list[lev]==INVALID ) {
//gapping starts
for (int i=lev; i!=k ; ) {
Node v=level_list[++i];
- while ( g->valid(v) ) {
+ while ( v!=INVALID ) {
level.set(v,n);
v=right[v];
}
@@ -906,7 +858,7 @@
if ( what_heur ) b=newlevel;
if ( k < newlevel ) ++k; //now k=newlevel
Node z=level_list[newlevel];
- if ( g->valid(z) ) left.set(z,w);
+ if ( z!=INVALID ) left.set(z,w);
right.set(w,z);
left.set(w,INVALID);
level_list[newlevel]=w;
@@ -917,26 +869,23 @@
void printexcess() {////
std::cout << "Excesses:" <<std::endl;
- NodeIt v;
- for(g->first(v); g->valid(v); g->next(v)) {
+ for(NodeIt v(*g); v!=INVALID ; ++v) {
std::cout << 1+(g->id(v)) << ":" << excess[v]<<std::endl;
}
}
- void printlevel() {////
+ void printlevel() {////
std::cout << "Levels:" <<std::endl;
- NodeIt v;
- for(g->first(v); g->valid(v); g->next(v)) {
+ for(NodeIt v(*g); v!=INVALID ; ++v) {
std::cout << 1+(g->id(v)) << ":" << level[v]<<std::endl;
}
}
-void printactive() {////
+ void printactive() {////
std::cout << "Levels:" <<std::endl;
- NodeIt v;
- for(g->first(v); g->valid(v); g->next(v)) {
+ for(NodeIt v(*g); v!=INVALID ; ++v) {
std::cout << 1+(g->id(v)) << ":" << level[v]<<std::endl;
}
}
More information about the Lemon-commits
mailing list