C++ ListDigraph::addArc方法代码示例

//Generate a random complete euclidean ListGraph
bool GenerateRandomEuclideanListDigraph(ListDigraph &g,
			  DNodeStringMap &vname, // node name
			  DNodePosMap    &px, // x-position of the node
			  DNodePosMap    &py, // y-position of the node
			  ArcValueMap  & weight, // weight of edges
			  int n, // number of nodes
			  double SizeX, // coordinate x is a random number in [0,SizeX)
			  double SizeY) // coordinate y is a random number in [0,SizeY)
{
  DNode *V;
  V = new DNode[n];
  if (V==NULL){
    cout << "Memory allocation error, number of nodes " << n << " too large\n";
    exit(0);}
  
  for (int i=0;i<n;i++) {   // insert nodes (random points in [0,100] x [0,100] )
    V[i] = g.addNode();    // new node
    px[V[i]] = SizeX*drand48();
    py[V[i]] = SizeY*drand48();
    vname[V[i]] = IntToString(i+1);// name of node is i+1
  }
  for (int i=0;i<n;i++)
    for (int j=i+1;j<n;j++) {
      Arc e = g.addArc(V[i],V[j]);  // generate new arc from v_i to v_j
      weight[e] = sqrt(pow(px[V[i]]-px[V[j]],2) + pow(py[V[i]]-py[V[j]],2));
      Arc f = g.addArc(V[j],V[i]);  // generate new arc from v_j to v_i
      weight[f] = weight[e];
    }
  delete[] V;
  return(true);
}

int main()
{

	ListDigraph test;
	ListDigraph::Node a = test.addNode();
	ListDigraph::Node b = test.addNode();
	ListDigraph::Node c = test.addNode();
	ListDigraph::Node d = test.addNode();
	ListDigraph::Node e = test.addNode();
	ListDigraph::Node f = test.addNode();

	ListDigraph::Arc ac  = test.addArc(a, c);
	ListDigraph::Arc bc  = test.addArc(b, c);
	ListDigraph::Arc cd  = test.addArc(c, d);
	ListDigraph::Arc bf  = test.addArc(b, f);
	ListDigraph::Arc de  = test.addArc(d, e);
	ListDigraph::Arc df  = test.addArc(d, f);

	ListDigraph::ArcMap<int> costs(test);

	costs[ac] = 1;
	costs[bc] = 2;
	costs[cd] = 2;
	costs[bf] = 32;
	costs[de] = 16;
	costs[df] = 8;

	solve_via_minflow(test, costs);

	return 0;
}

int read_pcpath(string input_file){
  std::ifstream kinput;
  kinput.open(input_file.c_str()); if (!kinput) return 0;
  kinput >> n >> m;
  std::map<std::string, ListDigraph::Node> ref;

  for ( int i=0; i<n; i++ ){
    string tmp;
    double r;
    kinput >> tmp >> r;
    ListDigraph::Node n = g.addNode();
    node_names[n] = tmp;
    prizes[n] = r;
    ref[tmp]=n;
  }

  for ( int i=0; i<m; i++){
    string v1, v2;
    double c_tmp;
    kinput >> v1 >> v2 >> c_tmp;
    ListDigraph::Arc a = g.addArc(ref[v1], ref[v2]);  //source, target
    costs[a] = c_tmp;
  }

  return 1;
}

//splits graph into connected components
void split_graph(ListDigraph& g, vector<ListDigraph*>& graphs){

	Undirector<ListDigraph> undirected(g);
	ListDigraph::NodeMap<int> components(g);
	stronglyConnectedComponents(undirected, components);

	int num_subgraphs = 0;
	for(ListDigraph::NodeIt n(g); n != INVALID; ++n){
		if(components[n] > num_subgraphs) num_subgraphs = components[n];
	}
	num_subgraphs++;
	ListDigraph::NodeMap<ListDigraph::Node> map(g);

	for(int i = 0; i < num_subgraphs; i++){
		ListDigraph temp;
		for(ListDigraph::NodeIt n(g); n != INVALID; ++n){
			if(components[n] == i){
				map[n] = temp.addNode();
			}
		}
		for(ListDigraph::NodeIt n(g); n != INVALID; ++n){
			if(components[n] == i){
				for(ListDigraph::OutArcIt o(g, n); o != INVALID; ++o){
					temp.addArc(map[g.source(o)], map[g.target(o)]);
				}
			}
		}
		graphs.push_back(&temp);
	}
}

void createMACGraph(ListDigraph& g, int num_paths, int path_length, ListDigraph::ArcMap<int>& demands){

	srand(time(NULL));

	ListDigraph::Node prev[num_paths];
	ListDigraph::Node current[num_paths];

	for (int i = 0; i < num_paths; ++i)
	{
		prev[i] = g.addNode();
	}
	for (int i = 0; i < path_length-1; ++i)
	{
		for (int j = 0; j < num_paths; ++j)
		{
			current[j] = g.addNode();
			g.addArc(prev[j], current[j]);
		}
		for (int j = 0; j < num_paths; ++j)
		{
			if(rand()%100 < 50){
				int targetIndex  = j;
				while(targetIndex != j){
					targetIndex = rand()%num_paths;
				}
				g.addArc(prev[j], current[targetIndex]);
			}
		}
		for (int j = 0; j < num_paths; ++j)
		{
			prev[j] = current[j];
		}

	}

	//this splits every node and sets demand for the edge between the halves to 1
	for (ListDigraph::NodeIt n(g); n != INVALID; ++n){
		ListDigraph::Node new_node = g.split(n, false);
		ListDigraph::Arc new_edge = g.addArc(n, new_node);
		demands[new_edge] = 1;
	}

}

void createKPathGraph(ListDigraph& g, int k, int n, int m, ListDigraph::ArcMap<int>& weights, ListDigraph::ArcMap<int>& demands){
	srand(time(NULL));

	ListDigraph::Node* nodes[k];
	for (int i = 0; i < k; ++i)
	{
		nodes[i] = (ListDigraph::Node*) calloc(n, sizeof(ListDigraph::Node));
	}
	for (int i = 0; i < k; ++i)
	{
		for (int j = 0; j < n; ++j)
		{
			nodes[i][j] = g.addNode();
			if(j != 0) g.addArc(nodes[i][j-1], nodes[i][j]);
		}
	}
	for (int i = 0; i < m; ++i)
	{
		int k1 = rand()%k;
		int k2 = rand()%k;
		int n1 = rand()%(n-1);
		int n2 = (rand()%(n-n1-1))+n1+1;

		if(findArc(g, nodes[k1][n1], nodes[k2][n2]) == INVALID){
			g.addArc(nodes[k1][n1], nodes[k2][n2]);
		}
	}
	for (ListDigraph::ArcIt a(g); a != INVALID; ++a)
	{
		weights[a] = rand()%1000;
	}
	
	//this splits every node and sets demand for the edge between the halves to 1
	for (ListDigraph::NodeIt n(g); n != INVALID; ++n){
		ListDigraph::Node new_node = g.split(n, false);
		ListDigraph::Arc new_edge = g.addArc(n, new_node);
		demands[new_edge] = 1;
	}
	

}

ListDigraph::Node addSink(ListDigraph& g){

  ListDigraph::Node t = g.addNode();  
  for(ListDigraph::NodeIt n(g); n != INVALID; ++n){
    
        if(countOutArcs(g, n) == 0 && n != t){
            g.addArc(n, t);
        }
    }
    
  return t;
}

ListDigraph::Node addSource(ListDigraph& g){

  ListDigraph::Node s = g.addNode();
  for(ListDigraph::NodeIt n(g); n != INVALID; ++n){
    
        if(countInArcs(g, n) == 0 && n != s){
            g.addArc(s, n);
        }
    }
    
  return s;
}

int main()
{
    ListDigraph g;

    ListDigraph::Node u = g.addNode();
    ListDigraph::Node v = g.addNode();
    ListDigraph::Arc  a = g.addArc( u, v );

    cout << "Hello World! This is LEMON library here." << endl;
    cout << "We have a directed graph with " << countNodes( g ) << " nodes "
         << "and " << countArcs( g ) << " arc." << endl;

    return 0;
}

//check for circle for each course with his pre courses
bool checkCircle(SeasonConfig  & seasonConfig) {

	ListDigraph g;
	CrossRefMap<ListDigraph, ListDigraph::Node, int> ids(g);
	ListDigraph::Node u, v;
	Bfs<ListDigraph> bfs(g);

	for (int i = 0; i < seasonConfig.courses.count(); i++){
		nodeValidation(seasonConfig.courses.get(i).getId(), ids, u, g);
		for (int j = 0; j < seasonConfig.courses.get(i).pre.count(); j++)
		{
			nodeValidation(seasonConfig.courses.get(i).pre.get(j).getId(), ids, v, g);
			bfs.run(v);

			if (bfs.reached(u)){ // If there is a path to u 
			
				return true; // circle was found we can exit the progeam;
			}
			g.addArc(u, v); // Else  we make a connection between u and v 
		}
	}
	return false;
}

//Simple function for generating acyclic graphs
void createRandomGraph(ListDigraph& g, int num_nodes, float edge_prob){

	srand(time(NULL));
	ListDigraph::NodeMap<int> labels(g);

	for(int i=0; i<num_nodes; i++){
		ListDigraph::Node new_node = g.addNode();
		labels[new_node] = i;
	}
	for(ListDigraph::NodeIt n(g); n != INVALID; ++n){
		for(ListDigraph::NodeIt v(g); v != INVALID; ++v){

			//no edges from bigger nodes to smaller to ensure acyclicity,
			//and no edges from node to itself
			//+ an attempt to create longer graphs
			if(labels[n] >= labels[v] || labels[n] < labels[v]-20) continue;

			if(rand()%100 <= edge_prob*100){
				g.addArc(n, v);
			}
		}
	}
}

// Generate a triangulated ListDigraph, building the Delaunay
// triangulation of random points. Each edge of the Delaunay triangulation
// leads to two arcs (in both senses)  
// Uses the geompack program, available in
// http://people.sc.fsu.edu/~jburkardt/cpp_src/geompack/geompack.html
bool GenerateTriangulatedListDigraph(ListDigraph &g,
		 DNodeStringMap &vname, // name of the nodes
		 DNodePosMap  &px, // x-position of the nodes
		 DNodePosMap  &py, // y-position of the nodes
		 ArcValueMap   & weight, // weight of edges
		 int n, // number of nodes
		 double SizeX, // coordinate x is a random number in [0,SizeX)
		 double SizeY) // coordinate y is a random number in [0,SizeY)
{
 int i; // n=number of nodes
 DNode *V = new DNode[n];
 double *p = new double[2*n+2];// node coodinates are (x;y) = ( p[2*i] ; p[2*i+1] )
 int *tri = new int[6*n]; // Each 3 elements are the indexes of a triangle
 int ntri;
 int *tri_nabe = new int[6*n];
  
  if ((V==NULL)||(p==NULL)||(tri==NULL)||(tri_nabe==NULL)){
    cout << "Memory allocation error, number of nodes " << n << " too large\n";
    exit(0);}

 for (i=0;i<n;i++) {   // insere os vértices (pontos aleatórios no plano [0,SizeX]x[0,SizeY] )
    V[i] = g.addNode(); // gera um vértice nó do grafo 
    px[V[i]] = SizeX*drand48();  // nodes are random points
    py[V[i]] = SizeY*drand48();
    p[2*i]   = px[V[i]];
    p[2*i+1] = py[V[i]];
    vname[V[i]] = IntToString(i+1);// name of node is i+1
  }
  if (r8tris2 ( n, p, &ntri, tri,  tri_nabe )) {  printf("ERROR\n");Pause(); }
  for (i=0;i<ntri;i++) { 
    int a,b,c;
    a = tri[3*i]-1; b = tri[3*i+1]-1; c = tri[3*i+2]-1;
    // each triangle if formed with nodes  V[a] , V[b] , V[c]
    // insert arcs without duplications in both senses
    if (findArc(g,V[a],V[b])==INVALID){
      Arc e = g.addArc(V[a],V[b]); 
      weight[e] = sqrt(pow(px[V[a]]-px[V[b]],2) + pow(py[V[a]]-py[V[b]],2));
    }
    if (findArc(g,V[b],V[a])==INVALID){
      Arc e = g.addArc(V[b],V[a]);  
      weight[e] = sqrt(pow(px[V[b]]-px[V[a]],2) + pow(py[V[b]]-py[V[a]],2));
    }
    if (findArc(g,V[a],V[c])==INVALID){
      Arc e = g.addArc(V[a],V[c]);  
      weight[e] = sqrt(pow(px[V[a]]-px[V[c]],2) + pow(py[V[a]]-py[V[c]],2));
    }
    if (findArc(g,V[c],V[a])==INVALID){
      Arc e = g.addArc(V[c],V[a]);  
      weight[e] = sqrt(pow(px[V[c]]-px[V[a]],2) + pow(py[V[c]]-py[V[a]],2));
    }
    if (findArc(g,V[b],V[c])==INVALID) {
      Arc e = g.addArc(V[b],V[c]);  
      weight[e] = sqrt(pow(px[V[b]]-px[V[c]],2) + pow(py[V[b]]-py[V[c]],2));
    }
    if (findArc(g,V[c],V[b])==INVALID) {
      Arc e = g.addArc(V[c],V[b]);  
      weight[e] = sqrt(pow(px[V[c]]-px[V[b]],2) + pow(py[V[c]]-py[V[b]],2));
    }
  }
  delete[] V;
  delete[] p;
  delete[] tri;
  delete[] tri_nabe;
  return(true);
}

bool ReadListDigraph(string filename,
		     ListDigraph &g,
		     DNodeStringMap  &vname,
		     ArcValueMap      &weight,
		     DNodePosMap     &posx,
		     DNodePosMap     & posy,
             DNodeBoolMap &is_terminal,
		     const bool dupla)
{
  ifstream ifile;
  int i,n,m;
  double peso;
  Arc a;
  char nomeu[100],nomev[100];
  string STR;
  DNode u,v;
#if __cplusplus >= 201103L
  std::unordered_map<string,DNode> string2node,test;
#else
  std::tr1::unordered_map<string,DNode> string2node;
#endif

  ifile.open(filename.c_str());
  if (!ifile) {cout << "File '" << filename << "' does not exist.\n"; exit(0);}
  PulaBrancoComentario(ifile);
  ifile >> n;    ifile >> m; // first line have number of nodes and number of arcs
  if (m<0 || ifile.eof())
    { cout<<"File "<<filename<<" is not a digraph given by arcs.\n"; exit(0);}

  for (i=0;i<n;i++) {
    getline(ifile,STR);
    if (ifile.eof()) {cout<<"Reached unexpected end of file "<<filename<<".\n";exit(0);}
    while (STR=="") getline(ifile,STR);
    {
      string token;
      istringstream ins; // Declare an input string stream.
      ins.str(STR);        // Specify string to read.
      int nt = 0;
      while( getline(ins, token, ' ') ) {
	// format: <node_name>  <pos_x>  <pos_y>   <is_terminal>
	if (nt==0) {
	  auto test = string2node.find(token);

	  if (test!=string2node.end()){cout<<"ERROR: Repeated node: "<<nomev<<endl;exit(0);}
	  v = g.addNode(); string2node[token] = v; vname[v] = token;}
	else if (nt==1) { posx[v] = atof(token.c_str());}
	else if (nt==2) { posy[v] = atof(token.c_str());}
    else if (nt==3) {
        if(atoi(token.c_str()) == 1)
            is_terminal[v] = true;
        else
            is_terminal[v] = false;
               }
	nt++;
      }
    }
  }
  for (i=0;i<m;i++) {
    // format: <node_source>   <node_target>   <arc_weight>
    ifile >> nomeu;  ifile >> nomev; ifile >> peso;
    if (ifile.eof()) 
      {cout << "Reached unexpected end of file " <<filename << ".\n"; exit(0);}
    auto test = string2node.find(nomeu);
    if (test == string2node.end()) {cout<<"ERROR: Unknown node: "<<nomeu<<endl;exit(0);}
    else u = string2node[nomeu];
    
    test = string2node.find(nomev);
    if (test == string2node.end()) {cout<<"ERROR: Unknown node: "<<nomev<<endl;exit(0);}
    else v = string2node[nomev];
    a = g.addArc(u,v); weight[a] = peso;
    if (dupla) {a = g.addArc(v,u);   weight[a] = peso;}
  }
  ifile.close();
  return(true);
}

using namespace std;
using namespace lemon;


TEST_CASE("MACs are found in an easy test case")
{
  ListDigraph g;
  ListDigraph::Node s = g.addNode();
  ListDigraph::Node t = g.addNode();
  ListDigraph::Node a = g.addNode();
  ListDigraph::Node b = g.addNode(); 
  ListDigraph::Node c = g.addNode();
  ListDigraph::Node d = g.addNode();

  ListDigraph::Arc sa = g.addArc(s, a);
  ListDigraph::Arc ab = g.addArc(a, b);
  ListDigraph::Arc bt = g.addArc(b, t);
  ListDigraph::Arc sc = g.addArc(s, c);
  ListDigraph::Arc cd = g.addArc(c, d);
  ListDigraph::Arc dt = g.addArc(d, t);

  ListDigraph::NodeMap<int> labels(g);
  int counter = 0;
  for(ListDigraph::NodeIt n(g); n != INVALID; ++n){
    labels[n] = counter;
    counter++;
  }
  ListDigraph::ArcMap<int> demand(g);
  for(ListDigraph::ArcIt ai(g); ai != INVALID; ++ai){
    demand[ai] = 1;