lemon-0.x: comparison src/work/jacint/max

equal deleted inserted replaced

-:6cd3db136077
+:8502f85f7c2b
 Node w=queue.front();
 	queue.pop();
 	OutEdgeIt e;
 	for(g->first(e,w) ; g->valid(e); g->next(e)) {
-	  Node v=g->head(e);
+	  Node v=g->target(e);
 	  if (!M[v] && (*flow)[e] < (*capacity)[e] ) {
 	    queue.push(v);
 	    M.set(v, true);
 	  }
 	}
 	InEdgeIt f;
 	for(g->first(f,w) ; g->valid(f); g->next(f)) {
-	  Node v=g->tail(f);
+	  Node v=g->source(f);
 	  if (!M[v] && (*flow)[f] > 0 ) {
 	    queue.push(v);
 	    M.set(v, true);
 	  }
 	}
 	queue.pop();
 	InEdgeIt e;
 	for(g->first(e,w) ; g->valid(e); g->next(e)) {
-	  Node v=g->tail(e);
+	  Node v=g->source(e);
 	  if (M[v] && (*flow)[e] < (*capacity)[e] ) {
 	    queue.push(v);
 	    M.set(v, false);
 	  }
 	}
 	OutEdgeIt f;
 	for(g->first(f,w) ; g->valid(f); g->next(f)) {
-	  Node v=g->head(f);
+	  Node v=g->target(f);
 	  if (M[v] && (*flow)[f] > 0 ) {
 	    queue.push(v);
 	    M.set(v, false);
 	  }
 	}
 OutEdgeIt e;
 for(g->first(e,w); g->valid(e); g->next(e)) {
 	if ( (*flow)[e] >= (*capacity)[e] ) continue;
-	Node v=g->head(e);
+	Node v=g->target(e);
 	if( lev > level[v] ) { //Push is allowed now
 	  if ( excess[v]<=0 && v!=t && v!=s ) {
 	    int lev_v=level[v];
 if ( exc > 0 ) {
 	InEdgeIt e;
 	for(g->first(e,w); g->valid(e); g->next(e)) {
 	  if( (*flow)[e] <= 0 ) continue;
-	  Node v=g->tail(e);
+	  Node v=g->source(e);
 	  if( lev > level[v] ) { //Push is allowed now
 	    if ( excess[v]<=0 && v!=t && v!=s ) {
 	      int lev_v=level[v];
 				  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);
+				    Node w=g->source(e);
 				    if ( level[w] == n && w != s ) {
 				      bfs_queue.push(w);
 				      Node first=level_list[l];
 				      if ( g->valid(first) ) left.set(first,w);
 				      right.set(w,first);
 				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);
+				    Node w=g->target(e);
 				    if ( level[w] < n ) {
 				      if ( excess[w] <= 0 && w!=t ) active[level[w]].push(w);
 				      flow->set(e, c);
 				      excess.set(w, excess[w]+c);
 				    }
 				  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);
+				    Node w=g->source(e);
 				    if ( level[w] == n && w != s ) {
 				      bfs_queue.push(w);
 				      Node first=level_list[l];
 				      if ( g->valid(first) ) left.set(first,w);
 				      right.set(w,first);
 				  }
 				  OutEdgeIt f;
 				  for(g->first(f,v); g->valid(f); g->next(f)) {
 				    if ( 0 >= (*flow)[f] ) continue;
-				    Node w=g->head(f);
+				    Node w=g->target(f);
 				    if ( level[w] == n && w != s ) {
 				      bfs_queue.push(w);
 				      Node first=level_list[l];
 				      if ( g->valid(first) ) left.set(first,w);
 				      right.set(w,first);
 				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);
+				    Node w=g->target(e);
 				    if ( level[w] < n ) {
 				      if ( excess[w] <= 0 && w!=t ) active[level[w]].push(w);
 				      flow->set(e, (*capacity)[e]);
 				      excess.set(w, excess[w]+rem);
 				    }
 				InEdgeIt f;
 				for(g->first(f,s); g->valid(f); g->next(f))
 				  {
 				    if ( (*flow)[f] <= 0 ) continue;
-				    Node w=g->tail(f);
+				    Node w=g->source(f);
 				    if ( level[w] < n ) {
 				      if ( excess[w] <= 0 && w!=t ) active[level[w]].push(w);
 				      excess.set(w, excess[w]+(*flow)[f]);
 				      flow->set(f, 0);
 				    }
 int operator[](const typename MapGraphWrapper::Node& n)
 { return dist[n]; }
 //       int get(const typename MapGraphWrapper::Node& n) const {
 // 	return dist[n]; }
 //       bool get(const typename MapGraphWrapper::Edge& e) const {
-// 	return (dist.get(g->tail(e))<dist.get(g->head(e))); }
+// 	return (dist.get(g->source(e))<dist.get(g->target(e))); }
 bool operator[](const typename MapGraphWrapper::Edge& e) const {
-	return (dist[g->tail(e)]<dist[g->head(e)]);
+	return (dist[g->source(e)]<dist[g->target(e)]);
 }
 };
 };
 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 u=g->tail(e);
+	Node u=g->source(e);
 	if ( level[u] >= n ) {
 	  bfs_queue.push(u);
 	  level.set(u, l);
 	  if ( excess[u] > 0 ) active[l].push(u);
 	}
 }
 OutEdgeIt f;
 for(g->first(f,v); g->valid(f); g->next(f)) {
 	if ( 0 >= (*flow)[f] ) continue;
-	Node u=g->head(f);
+	Node u=g->target(f);
 	if ( level[u] >= n ) {
 	  bfs_queue.push(u);
 	  level.set(u, l);
 	  if ( excess[u] > 0 ) active[l].push(u);
 	}
 //searching for augmenting path
 while ( !bfs.finished() ) {
 ResGWOutEdgeIt e=bfs;
 if (res_graph.valid(e) && bfs.isBNodeNewlyReached()) {
-	Node v=res_graph.tail(e);
+	Node v=res_graph.source(e);
-	Node w=res_graph.head(e);
+	Node w=res_graph.target(e);
 	pred.set(w, e);
 	if (res_graph.valid(pred[v])) {
 	  free.set(w, std::min(free[v], res_graph.resCap(e)));
 	} else {
 	  free.set(w, res_graph.resCap(e));
 	}
-	if (res_graph.head(e)==t) { _augment=true; break; }
+	if (res_graph.target(e)==t) { _augment=true; break; }
 }
 ++bfs;
 } //end of searching augmenting path
 Node n=t;
 Num augment_value=free[t];
 while (res_graph.valid(pred[n])) {
 	ResGWEdge e=pred[n];
 	res_graph.augment(e, augment_value);
-	n=res_graph.tail(e);
+	n=res_graph.source(e);
 }
 }
 return _augment;
 }
 while ( !bfs.finished() ) {
 ResGWOutEdgeIt e=bfs;
 if (res_graph.valid(e)) {
 	if (bfs.isBNodeNewlyReached()) {
-	  dist.set(res_graph.head(e), dist[res_graph.tail(e)]+1);
+	  dist.set(res_graph.target(e), dist[res_graph.source(e)]+1);
-	  typename MG::Edge f=F.addEdge(res_graph_to_F[res_graph.tail(e)], res_graph_to_F[res_graph.head(e)]);
+	  typename MG::Edge f=F.addEdge(res_graph_to_F[res_graph.source(e)], res_graph_to_F[res_graph.target(e)]);
 	  original_edge.update();
 	  original_edge.set(f, e);
 	  residual_capacity.update();
 	  residual_capacity.set(f, res_graph.resCap(e));
 	} else {
-	  if (dist[res_graph.head(e)]==(dist[res_graph.tail(e)]+1)) {
+	  if (dist[res_graph.target(e)]==(dist[res_graph.source(e)]+1)) {
-	    typename MG::Edge f=F.addEdge(res_graph_to_F[res_graph.tail(e)], res_graph_to_F[res_graph.head(e)]);
+	    typename MG::Edge f=F.addEdge(res_graph_to_F[res_graph.source(e)], res_graph_to_F[res_graph.target(e)]);
 	    original_edge.update();
 	    original_edge.set(f, e);
 	    residual_capacity.update();
 	    residual_capacity.set(f, res_graph.resCap(e));
 	  }
 	typename MG::Node n=tF;
 	Num augment_value=free[tF];
 	while (F.valid(pred[n])) {
 	  typename MG::Edge e=pred[n];
 	  res_graph.augment(original_edge[e], augment_value);
-	  n=F.tail(e);
+	  n=F.source(e);
 	  if (residual_capacity[e]==augment_value)
 	    F.erase(e);
 	  else
 	    residual_capacity.set(e, residual_capacity[e]-augment_value);
 	}
 bfs.pushAndSetReached(s);
 DistanceMap<ResGW> dist(res_graph);
 while ( !bfs.finished() ) {
 ResGWOutEdgeIt e=bfs;
 if (res_graph.valid(e) && bfs.isBNodeNewlyReached()) {
-	dist.set(res_graph.head(e), dist[res_graph.tail(e)]+1);
+	dist.set(res_graph.target(e), dist[res_graph.source(e)]+1);
 }
 ++bfs;
 } //computing distances from s in the residual graph
 //Subgraph containing the edges on some shortest paths
 	// 	  Num j2=a2[b2];
 	Num augment_value=free1[n];
 	while (erasing_res_graph.valid(pred[n])) {
 	  typename ErasingResGW::OutEdgeIt e=pred[n];
 	  res_graph.augment(e, augment_value);
-	  n=erasing_res_graph.tail(e);
+	  n=erasing_res_graph.source(e);
 	  if (res_graph.resCap(e)==0)
 	    erasing_res_graph.erase(e);
 	}
 }

changeset 1068	e0b0dcee5e17
parent 921	818510fa3d99