private List <Vertice <int> > _caminoMayor(List <Vertice <int> > camino, Vertice <int> origen, Vertice <int> destino, bool[] visitados, List <Vertice <int> > mejorCamino)
{
camino.Add(origen);
visitados[origen.getPosicion() - 1] = true;
if (origen == destino)
{
int tiempo = 0;
for (int i = 0; i < camino.Count; i++)
{
tiempo += camino[i].getDato();
List <Arista <int> > adyacentes = camino[i].getAdyacentes();
for (int j = 0; j < adyacentes.Count; j++)
{
if (i != camino.Count - 1)
{
if (adyacentes[j].getDestino() == camino[i + 1])
{
tiempo += adyacentes[j].getPeso();
}
}
}
}
if (camino.Count >= mejorCamino.Count && tiempo <= 120) //120 min = 2 hs
{
mejorCamino.Clear();
mejorCamino.AddRange(camino);
}
return(camino);
}
else
{
foreach (var ady in origen.getAdyacentes())
{
if (!visitados[ady.getDestino().getPosicion() - 1])
{
this._caminoMayor(camino, ady.getDestino(), destino, visitados, mejorCamino);
visitados[ady.getDestino().getPosicion() - 1] = false;
camino.RemoveAt(camino.Count - 1);
}
}
}
return(null);
}
public void algoritmoDijkstra(Grafo <int> grafo, Vertice <int> origen)
{
List <Vertice <int> > verticesAux = grafo.getVertices();
Vertice <int>[] vertices = new Vertice <int> [verticesAux.Count];
int[] distancia = new int[verticesAux.Count];
bool[] procesado = new bool[verticesAux.Count];
vertices[0] = origen;
//procesado[0] = true;
distancia[0] = 0;
for (int i = 0; i < vertices.Length; i++)
{
if (verticesAux[i] != origen)
{
vertices[i] = verticesAux[i];
distancia[i] = int.MaxValue;
}
}
this._algoritmoDijkstra(vertices, distancia, procesado);
}
public List<Vertice<int>> verticesADistanciaConBFS(Grafo<int> grafo,Vertice<int> origen, int aristas)
{
bool[] visitados = new bool[grafo.getVertices().Count];
Cola<Vertice<int>> c = new Cola<Vertice<int>>();
List<Vertice<int>> listaV = new List<Vertice<int>>();
Vertice<int> vertAux;
int nivel = 0;
c.encolar(origen);
c.encolar(null);
visitados[origen.getPosicion() -1] = true;
while(!c.esVacia())
{
vertAux = c.desencolar();
if(vertAux == null)
{
if(nivel == aristas)
{
return listaV;
}
nivel++;
listaV.Clear();
if(!c.esVacia())
{
c.encolar(null);
}
}
if(vertAux != null)
{
listaV.Add(vertAux);
foreach (var ady in vertAux.getAdyacentes())
{
if(!visitados[ady.getDestino().getPosicion() - 1])
{
c.encolar(ady.getDestino());
visitados[ady.getDestino().getPosicion() - 1] = true;
}
}
}
}
return null;
}
public void BFS(Vertice <T> origen)
{
bool[] visitados = new bool[this.vertices.Count];
Cola <Vertice <T> > c = new Cola <Vertice <T> >();
Vertice <T> vertAux;
c.encolar(origen);
visitados[origen.getPosicion() - 1] = true;
while (!c.esVacia())
{
vertAux = c.desencolar();
Console.Write(vertAux.getDato() + " ");
foreach (var ady in vertAux.getAdyacentes())
{
if (!visitados[ady.getDestino().getPosicion() - 1])
{
c.encolar(ady.getDestino());
visitados[ady.getDestino().getPosicion() - 1] = true;
}
}
}
}
public List <Vertice <int> > caminoMayor(Grafo <int> grafo, Vertice <int> origen)
{
bool[] visitados = new bool[grafo.getVertices().Count];
List <List <Vertice <int> > > mejoresCaminos = new List <List <Vertice <int> > >();
foreach (var vertice in grafo.getVertices())
{
List <Vertice <int> > camino = new List <Vertice <int> >();
List <Vertice <int> > mejorCaminoAux = new List <Vertice <int> >();
this._caminoMayor(camino, origen, vertice, visitados, mejorCaminoAux);
mejoresCaminos.Add(mejorCaminoAux);
}
List <Vertice <int> > mejorCamino = mejoresCaminos[0];
foreach (var camino in mejoresCaminos)
{
if (camino.Count > mejorCamino.Count)
{
mejorCamino.Clear();
mejorCamino.AddRange(camino);
}
}
return(mejorCamino);
}
public void DFS(Vertice <T> origen)
{
bool[] visitados = new bool[this.vertices.Count];
this._DFS(origen, visitados);
}
public void desConectar(Vertice <T> origen, Vertice <T> destino)
{
Arista <T> arista = origen.getAdyacentes().Find(a => a.getDestino().Equals(destino));
origen.getAdyacentes().Remove(arista);
}
public void conectar(Vertice <T> origen, Vertice <T> destino, int peso)
{
origen.getAdyacentes().Add(new Arista <T>(destino, peso));
destino.aumentarGradoEntrada();
}
public void eliminarVertice(Vertice <T> v)
{
vertices.Remove(v);
}
public void agregarVertice(Vertice <T> v)
{
v.setPosicion(vertices.Count + 1);
vertices.Add(v);
}
static void Main(string[] args)
{
Grafo <string> gr = new Grafo <string>();
Vertice <string> lp = new Vertice <string>("La plata");
Vertice <string> pi = new Vertice <string>("Pilar");
Vertice <string> ta = new Vertice <string>("Tandil");
Vertice <string> ma = new Vertice <string>("Madariaga");
Vertice <string> le = new Vertice <string>("Lezama");
Vertice <string> mda = new Vertice <string>("Mar de Ajo");
Vertice <string> mdq = new Vertice <string>("Mar del plata");
Vertice <string> vg = new Vertice <string>("Villa Gessel");
Vertice <string> pin = new Vertice <string>("Pinamar");
gr.agregarVertice(lp);
gr.agregarVertice(pi);
gr.agregarVertice(ta);
gr.agregarVertice(ma);
gr.agregarVertice(le);
gr.agregarVertice(mda);
gr.agregarVertice(mdq);
gr.agregarVertice(vg);
gr.agregarVertice(pin);
gr.conectar(lp, ta, 0);
gr.conectar(ta, lp, 0);
gr.conectar(lp, le, 0);
gr.conectar(le, lp, 0);
gr.conectar(le, pi, 0);
gr.conectar(pi, le, 0);
gr.conectar(le, mda, 0);
gr.conectar(mda, le, 0);
gr.conectar(ta, pi, 0);
gr.conectar(pi, ta, 0);
gr.conectar(ta, ma, 0);
gr.conectar(ma, ta, 0);
gr.conectar(mdq, ta, 0);
gr.conectar(ta, mdq, 0);
gr.conectar(pi, ma, 0);
gr.conectar(ma, pi, 0);
gr.conectar(pi, mda, 0);
gr.conectar(mda, pi, 0);
gr.conectar(mda, pin, 0);
gr.conectar(pin, mda, 0);
gr.conectar(mdq, vg, 0);
gr.conectar(vg, mdq, 0);
gr.conectar(pin, ma, 0);
gr.conectar(ma, pin, 0);
gr.conectar(pin, vg, 0);
gr.conectar(vg, pin, 0);
Console.WriteLine("Recorrido DFS GRAFO 1:");
gr.DFS(lp);
Console.WriteLine("\nRecorrido BFS GRAFO 1:");
gr.BFS(lp);
//****************************
Grafo <int> gr2 = new Grafo <int>();
Vertice <int> uno = new Vertice <int>(1);
Vertice <int> dos = new Vertice <int>(2);
Vertice <int> cuatro = new Vertice <int>(4);
Vertice <int> cinco = new Vertice <int>(5);
Vertice <int> tres = new Vertice <int>(3);
Vertice <int> seis = new Vertice <int>(6);
Vertice <int> siete = new Vertice <int>(7);
gr2.agregarVertice(uno);
gr2.agregarVertice(dos);
gr2.agregarVertice(cuatro);
gr2.agregarVertice(cinco);
gr2.agregarVertice(tres);
gr2.agregarVertice(seis);
gr2.agregarVertice(siete);
gr2.conectar(uno, dos, 5);
gr2.conectar(uno, cuatro, 7);
gr2.conectar(dos, cinco, 3);
gr2.conectar(tres, cinco, 6);
gr2.conectar(cuatro, tres, 8);
gr2.conectar(cuatro, cinco, 5);
gr2.conectar(cuatro, seis, 6);
gr2.conectar(cuatro, dos, 2);
gr2.conectar(cinco, siete, 3);
gr2.conectar(seis, tres, 1);
gr2.conectar(seis, siete, 4);
Console.WriteLine("\nBFS GRAFO 2");
gr2.BFS(uno);
Console.WriteLine("\nBuscador camino");
Recorrido r = new Recorrido();
r.caminoSimpleConDFS(gr2, uno, seis);
Console.WriteLine("\nDistancia camino");
foreach (var dato in r.verticesADistanciaConBFS(gr2, uno, 1))
{
Console.Write(dato.getDato() + " ");
}
Console.WriteLine("\n----------EJERCICIO 3----------");
Ejercicio3 ej3 = new Ejercicio3();
Console.WriteLine("\nMínimo de encrucijadas: " + ej3.minEncrucijadas(gr, pin, ma));
Console.WriteLine("\n----------EJERCICIO 4----------");
Grafo <int> grafo3 = new Grafo <int>();
Vertice <int> c1 = new Vertice <int>(1);
Vertice <int> c2 = new Vertice <int>(2);
Vertice <int> c4 = new Vertice <int>(4);
Vertice <int> c5 = new Vertice <int>(5);
Vertice <int> c3 = new Vertice <int>(3);
grafo3.agregarVertice(c1);
grafo3.agregarVertice(c2);
grafo3.agregarVertice(c3);
grafo3.agregarVertice(c4);
grafo3.agregarVertice(c5);
grafo3.conectar(c1, c3, 0);
grafo3.conectar(c3, c5, 0);
grafo3.conectar(c2, c3, 0);
grafo3.conectar(c2, c4, 0);
grafo3.conectar(c4, c5, 0);
OrdenTopologico topo = new OrdenTopologico();
Console.WriteLine("\nORDEN TOPOLOGICO!!!");
foreach (var vertice in topo.ordenTopologico(grafo3))
{
Console.Write(vertice.getDato() + " ");
}
Console.WriteLine("\n-------------EJERCICIO 5-------------");
Grafo <int> grafo4 = new Grafo <int>();
Vertice <int> v1 = new Vertice <int>(15);
Vertice <int> v2 = new Vertice <int>(45);
Vertice <int> v3 = new Vertice <int>(10);
Vertice <int> v4 = new Vertice <int>(50);
Vertice <int> v5 = new Vertice <int>(15);
grafo4.agregarVertice(v1);
grafo4.agregarVertice(v2);
grafo4.agregarVertice(v3);
grafo4.agregarVertice(v4);
grafo4.agregarVertice(v5);
grafo4.conectar(v1, v2, 15);
grafo4.conectar(v1, v4, 10);
grafo4.conectar(v2, v1, 15);
grafo4.conectar(v2, v4, 15);
grafo4.conectar(v2, v5, 15);
grafo4.conectar(v2, v3, 15);
grafo4.conectar(v3, v5, 0);
grafo4.conectar(v3, v2, 15);
grafo4.conectar(v4, v1, 10);
grafo4.conectar(v4, v2, 15);
grafo4.conectar(v4, v5, 10);
grafo4.conectar(v5, v2, 15);
grafo4.conectar(v5, v3, 0);
grafo4.conectar(v5, v4, 10);
Grafo <int> grafo5 = new Grafo <int>();
Ejercicio5 mejorCamino = new Ejercicio5();
foreach (var vertice in mejorCamino.caminoMayor(grafo4, v1))
{
Console.Write(vertice.getDato() + " ");
}
Console.WriteLine("\n--------------DIJKSTRA ALGORITHM!!!---------");
Dijkstra dijkstra = new Dijkstra();
dijkstra.algoritmoDijkstra(gr2, uno);
}
public Arista(Vertice <T> dest, int p)
{
destino = dest;
peso = p;
}
public void setDestino(Vertice <T> destino)
{
this.destino = destino;
}
private List <Vertice <string> > _minEncrucijadas(List <Vertice <string> > camino, Vertice <string> origen, Vertice <string> destino, bool[] visitados, List <Vertice <string> > mejorCamino)
{
camino.Add(origen);
visitados[origen.getPosicion() - 1] = true;
if (origen == destino)
{
//Console.WriteLine("\nLongitud camino actual: "+camino.Count);
//Console.WriteLine("\nLongitud mejor camino: "+mejorCamino.Count);
foreach (var vertice in camino)
{
Console.Write(vertice.getDato() + " ");
}
if (camino.Count < mejorCamino.Count)
{
//Console.WriteLine("\nHaciendo la copia.");
mejorCamino.Clear();
mejorCamino.AddRange(camino);
}
return(camino);
}
else
{
foreach (var ady in origen.getAdyacentes())
{
if (!visitados[ady.getDestino().getPosicion() - 1])
{
this._minEncrucijadas(camino, ady.getDestino(), destino, visitados, mejorCamino);
visitados[ady.getDestino().getPosicion() - 1] = false;
camino.RemoveAt(camino.Count - 1);
}
}
}
return(null);
}
private List<Vertice<int>> _caminoSimpleConDFS(List<Vertice<int>> camino, Vertice<int> origen, Vertice<int> destino, bool[] visitados)
{
camino.Add(origen);
visitados[origen.getPosicion()-1] = true;
if(origen == destino)
{
foreach (var vertice in camino)
{
Console.Write(vertice.getDato() + " ");
}
return camino;
}
else
{
foreach (var ady in origen.getAdyacentes())
{
if(!visitados[ady.getDestino().getPosicion() - 1])
{
this._caminoSimpleConDFS(camino,ady.getDestino(),destino,visitados);
camino.RemoveAt(camino.Count-1);
}
}
}
return null;
}
public List<Vertice<int>> caminoSimpleConDFS(Grafo<int> grafo, Vertice<int> origen, Vertice<int> destino)
{
bool[] visitados = new bool[grafo.getVertices().Count];
List<Vertice<int>> camino = new List<Vertice<int>>();
return this._caminoSimpleConDFS(camino,origen,destino,visitados);
}
