Beispiel #1
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;
}
Beispiel #2
0
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[])
{
     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;
}
Beispiel #4
0
int main(int argc, char *argv[])
{
    enum {A, B, C, D};
    Grafo<int> g;
    g.agregarVertice(A);
    g.agregarVertice(B);
    g.agregarVertice(C);
    g.agregarVertice(D);

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

    if (existe_camino_long(g, A, D, 8, 0))
        cout << "si, existe" << endl;
    else
        cout << "no existe" << endl;
    return 0;
}
int main(int argc, char **argv)
{


	Grafo<int> g;

	// Cargamos un grafo dirigido
	// Primero los vértices
	g.agregarVertice(1);
	g.agregarVertice(2);
	g.agregarVertice(2);
	g.agregarVertice(3);
	g.agregarVertice(4);
	g.agregarVertice(5);
	g.agregarVertice(6);
	g.agregarVertice(7);
	g.agregarVertice(8);
	g.agregarVertice(9);
	// Luego los arcos
	g.agregarArco(1,2,1);
	g.agregarArco(2,3,1);
	g.agregarArco(1,4,1);
	g.agregarArco(4,7,1);
	g.agregarArco(5,4,1);
	g.agregarArco(5,3,1);
	g.agregarArco(6,3,1);
	g.agregarArco(8,3,1);
	g.agregarArco(7,6,1);
	g.agregarArco(7,10,1);
	g.agregarArco(10,9,1);
	g.agregarArco(10,8,1);
	g.agregarArco(9,8,1);


cout<< " Estructura Grafo :"<< g;
g.vaciar();
cout<< " Estructura Grafo :"<< g;
}
void traspuesta_grafo(const Grafo<C> & g, Grafo<C> & r)
{
     Lista<int> vertices;
     g.devolverVertices(vertices);
     Lista<int>::Iterador it_v = vertices.devolverIterador();
     while (!it_v.llegoAlFinal()) {
	  r.agregarVertice(it_v.elementoActual());
	  it_v.avanzar();
     }
     it_v = vertices.devolverIterador();
     while (!it_v.llegoAlFinal()) {
	  int v = it_v.elementoActual();
	  Lista<typename Grafo<C>::Arco> adyacentes;
	  g.devolverAdyacentes(v, adyacentes);
	  typename Lista<typename Grafo<C>::Arco>::Iterador ady = adyacentes.devolverIterador();
	  while (!ady.llegoAlFinal()) {
	       r.agregarArco(ady.elementoActual().devolverAdyacente(),
			     v, ady.elementoActual().devolverCosto());
	       ady.avanzar();
	  }
	  it_v.avanzar();
     }
}