C++ Grafo类代码示例

void componentes_fuertes(const Grafo<C> & g, Lista<Lista<int> > & componentes)
{
     // se asume que los vertices fueron numerados de 0 a long-1
     bool visitado[g.devolverLongitud()];
     for (int i = 0; i < g.devolverLongitud(); i++)
	  visitado[i] =  false;
     
     Lista<int> vertices;
     Lista<int> recorrido;
     g.devolverVertices(vertices);
     Lista<int>::Iterador it_v = vertices.devolverIterador();
     while (!it_v.llegoAlFinal()) {
	  int v = it_v.elementoActual();
	  if (!visitado[v])
	       dfs_visit(g, v, visitado, recorrido);
	  it_v.avanzar();
     }

     Grafo<C> g_trasp;
     traspuesta_grafo(g, g_trasp);

     for (int i = 0; i < g.devolverLongitud(); i++)
	  visitado[i] =  false;
     
     it_v = recorrido.devolverIterador();
     while (!it_v.llegoAlFinal()) {
	  int v = it_v.elementoActual();
	  if (!visitado[v]) {
	       Lista<int> componente;
	       dfs_visit(g_trasp, v, visitado, componente);
	       componentes.agregarFinal(componente);
	  }
	  it_v.avanzar();
     }
}

void build_test_graph(Grafo & g)
{
  g.insert_node("A");
  g.insert_node("B");
  g.insert_node("C");
  g.insert_node("D");
  g.insert_node("E");
  g.insert_node("F");
  g.insert_node("G");
  g.insert_node("H");
  g.insert_node("I");

  insertar_arco(g, "A", "B", 2);
  insertar_arco(g, "A", "F", 5);
  insertar_arco(g, "B", "F", 1);
  insertar_arco(g, "B", "D", 3);
  insertar_arco(g, "C", "A", 1);  
  insertar_arco(g, "C", "E", 4);  
  insertar_arco(g, "F", "D", -2);
  insertar_arco(g, "F", "C", -1);
  insertar_arco(g, "F", "E", 2);
  insertar_arco(g, "D", "F", 2);
  insertar_arco(g, "D", "H", 4);
  insertar_arco(g, "E", "G", 2);
  insertar_arco(g, "E", "I", -2);
  insertar_arco(g, "G", "D", 3);
  insertar_arco(g, "G", "F", -1);
  insertar_arco(g, "G", "H", 2);
  insertar_arco(g, "H", "D", -2);
  insertar_arco(g, "H", "G", -1);
  insertar_arco(g, "I", "G", 4);
  insertar_arco(g, "I", "H", 3);

}

std::vector<int> Grafo::OrdemTopologica() {
	std::vector<int> listaOrdenado;
	std::vector<int> lSemArestas;
	Grafo * clone = new Grafo(*this);
	int id;
	bool dag = true;
	lSemArestas = clone->GetConjVertices();
	while ((int) lSemArestas.size() > 0) {
		id = lSemArestas[0];
		lSemArestas.erase(lSemArestas.begin());
		clone->RemoveVertice(id);
		//cout << "lSemArestas[0]: " << lSemArestas[0] << endl;
		//remova um nodo n de S
		//insira n em L
		listaOrdenado.push_back(id);

		if ((int) lSemArestas.size() == 0) {
			lSemArestas.clear();
			lSemArestas = clone->GetConjVertices();
			if ((int) lSemArestas.size() == 0 && clone->nrElementos > 0) {
				dag = false;
				break;
			}
			//for (int i =0; i < (int) lSemArestas.size(); i++)
			//	cout << "lSemArestas[i]: " << lSemArestas[i] << endl;
		}
	}
	if (!dag) {
		listaOrdenado.clear();
	}
	return listaOrdenado;
}

int main(int argc, char *argv[])
{
     const int n = 3;
     enum {A, B, C};
     Grafo<int> g;
     g.agregarVertice(A);
     g.agregarVertice(B);
     g.agregarVertice(C);

     g.agregarArco(A, B, 1);
     g.agregarArco(B, C, 1);
     g.agregarArco(C, A, 1);

     bool visitado[n];
     bool hay_ciclo =  false;
     int i = 0;
     while (!hay_ciclo && i < n) {
	  for (int k = 0; k < n; k++)
	       visitado[k] = false;

	  hay_ciclo = ciclo_hamilton(g, i, visitado, 0, i);
	  i++;
     }
     if (hay_ciclo)
	  cout << "hay ciclo de hamilton" << endl;
     else
	  cout << "no hay ciclo de hamilton" << endl;
     return 0;
}

int main(int argc, char **argv)
{
	Grafo<int> g;
	enum {A, B, C, D};
	const int n = 4;
	g.agregarVertice(A);
	g.agregarVertice(B);
	g.agregarVertice(C);
	g.agregarVertice(D);

	g.agregarArco(A, B, 1);
	g.agregarArco(A, C, 1);
	g.agregarArco(C, B, 1);
	g.agregarArco(B, D, 1);

	Lista<int> camino_parcial;
	Lista<Lista<int> > caminos;
	int tiempo = 0;
	
	bool visitado[n];
	for (int i = 0; i < n; i++)
	{
		visitado[i] = false;
	}
	caminos_simples(g, A, D,
			visitado, caminos, camino_parcial);
	const char impr[] = "ABCD";
	mostrar_caminos(g, caminos, impr);
	
	return 0;
}

        bool operator =(Grafo<int> &g) {

            if (this == &g)
                return *this;

            vaciar();

            list<int> v;
            g.getVertices(v);
            list<int>::iterator it = v.begin();

            while ( it != v.end()) {
                list<int> ady;
                g.getAdyacentes(*it, ady);
                agregarVertice(*it);
                list<int>::iterator itad = ady.begin();

                while ( itad != ady.end()) {
                    agregarArcoNoDireccional(*it, *itad);
                    itad++;
                }

                it++;
            }
        }

void DlgConsultarArista::aceptar(wxCommandEvent &event)
{

    wxString inicio = inicios->GetValue();
    wxString destino = destinos->GetValue();

    wxChar ini = inicio.GetChar(0);
    wxChar dest = destino.GetChar(0);

    char i = (char) ini;
    char d = (char) dest;

    if (drawpanel != NULL){
		Grafo* g = drawpanel->getGrafo();
		int pesoArista = g->consultarArista(i, d);
		if (pesoArista != -1){
            peso->Clear();
            peso->AppendText( wxString::Format(wxT("%i"),pesoArista)  );
		}
		else{
            peso->Clear();
            peso->AppendText( wxT("N/E") );
		}
    }
}

ComponentesConexas::ComponentesConexas(Grafo const& G) : marked(G.V(), false), _id(G.V()),
    _size(G.V(),0), _count(0) {
        for (auto v = 0; v < G.V(); ++v) {
            if (!marked[v]) { // se recorre una nueva componente conexa
                dfs(G, v);
                ++_count;
            }
        }
    }

int main(int argc, char *argv[])
{
     enum {a, b, c, d, e, f, g, h};
     const int n = 8;

     Grafo<int> gr;
     for (int i = 0; i < n; i++)
	  gr.agregarVertice(i);
     
     gr.agregarArco(a, b, 1);
     gr.agregarArco(b, f, 1);
     gr.agregarArco(b, c, 1);
     gr.agregarArco(b, e, 1);
     gr.agregarArco(c, d, 1);
     gr.agregarArco(c, g, 1);
     gr.agregarArco(d, c, 1);
     gr.agregarArco(d, h, 1);
     gr.agregarArco(e, a, 1);
     gr.agregarArco(e, f, 1);
     gr.agregarArco(f, g, 1);
     gr.agregarArco(g, f, 1);
     gr.agregarArco(h, h, 1);
     
     Lista<Lista<int> > componentes;
     componentes_fuertes(gr, componentes);
     mostrar_componentes(componentes, "abcdefgh");
     return 0;
}

Grafo::Grafo(const Grafo & cGrafo) {
	this->direcionado = cGrafo.Direcionado();
	this->tamGrafo = cGrafo.GetTamGrafo();
	this->nrElementos = cGrafo.GetElementos();
	this->debug = false;
	this->lVertice = new Vertice [ this->tamGrafo ];
	for (int i = 0; i < this->tamGrafo; i++) {
		Vertice * nVertice = new Vertice(cGrafo.GetVertice(i));
		this->lVertice[i] = *nVertice;
	}
}

void buscarCaminoMinimo(int cantidadEstaciones, int cantidadVias, int* vias){	
	Grafo fortaleza = Grafo(vias, cantidadEstaciones, cantidadVias); //fancy arreglo de listas enlazadas

	int distance[cantidadEstaciones];
	int prev[cantidadEstaciones];
	int salida = cantidadEstaciones - 1;	
	//la cola de prioridad, true si ya lo visitamos
	bool noVisitados[cantidadEstaciones];
	
	for(int i = 0; i < cantidadEstaciones; i++){
		distance[i] = -1;
		prev[i] = -1;
		noVisitados[i] = true;
	}

	distance[0] = 0;
	int actual;
	std::list<Arista>* vecinos; 
	std::list<Arista>::iterator posActual;

	while( (actual = masCercano(noVisitados, distance, cantidadEstaciones)) != -1 ){ //O(n)
	
		noVisitados[actual] = false; //lo saco de la "cola"
		if(actual == salida) break; //ya tiene una distancia y prev asignados
		
		vecinos = fortaleza.vecinos(actual);
		for(posActual = vecinos->begin(); posActual != vecinos->end(); ++posActual){ 
			Arista v = *posActual;
			int alt = distance[actual] + v.peso; //si la distancia la guarda el nodo: v.distance;
			if( alt < distance[v.destino] || distance[v.destino] == -1){
				distance[v.destino] = alt;
				prev[v.destino] = actual;
			}

		}
	}

	//recorrer el arreglo prev y ahi tengo los vertices necesarios.
	int j = salida;
	//printf("%d\n", distance[j]);
	if(distance[j] != -1){
		std::list<int> output;
		std::list<int>::iterator itOut;
		while( j >= 0 ){
			output.push_front(j);
			j = prev[j]; //prev[0] esta en -1 entonces ahi corta el ciclo
		}
		//printf( "%lu\n", output.size() );
		for(itOut = output.begin(); itOut != output.end(); ++itOut){ 
		//	printf("%d ", *itOut + 1); //imprimo estaciones
		}
		//printf("\n");
	}
}

Grafo * Reader::getSteiner(int * &terminais, int * vet_size){
    string linha;
    int entrada, saida, forca;
    int size;
    
    inputFile.open(input_name);
    
    while (inputFile >> linha){
        if (linha == "Nodes")
            break;
    }
    
    inputFile >> linha;
    
    size = atoi(linha.c_str());
    
    Grafo * g = new Grafo(size);
    
    inputFile >> linha;
    inputFile >> linha;
    
    while(inputFile >> linha){
        if(linha == "END")
            break;
        inputFile >> entrada;
        inputFile >> saida;
        inputFile >> forca;
        g->adicionaRelacao((entrada % size), (saida % size), forca);
    }
    
    inputFile >> linha;
    inputFile >> linha;
    inputFile >> linha;
    
    inputFile >> *vet_size;
    
    terminais = new int [*vet_size];
    
    int i = 0;
    
    while(inputFile >> linha){
        if(linha == "END")
            break;
        
        inputFile >> terminais[i];
        i++;
    }
    
    inputFile.close();
    
    return g;

}

int main()  
{
  {
    Grafo g; // grafo con un punto de corte

    construir_grafo(g); 

    ofstream f("test-cut.Tree", ios::trunc);

    write_df_low_tree(g, g.get_first_node(), f);

  }
}

Grafo<unsigned int> Prim2opt::getMinimumSpanningTree(int raiz[], unsigned int costo[], unsigned int N, unsigned int r) {
    Grafo<unsigned int> g;

    for (unsigned int i = 1; i < N; i++) {
        g.addVertex(i);
    }
    for (unsigned int i = 1; i < N; i++) {
        if (i != r)
            g.addNonDirectionalEdge(i, raiz[i], costo[i]);
    }

    return g;
}

void imprimir_arcos(Grafo & g, const long & color)
{
  cout << "Listado de arcos con color " << color << endl;
  for (Grafo::Arc_Iterator it(g); it.has_current(); it.next())
    {
      Grafo::Arc * arc = it.get_current_arc();

      if (g.get_counter(arc) == color)
	cout << "Arco de " << g.get_src_node(arc)->get_info().clave
	     << " a " << g.get_tgt_node(arc)->get_info().clave << endl;
    }
  cout << endl;
}