public int minEncrucijadas(Grafo <string> grafo, Vertice <string> origen, Vertice <string> destino)
        {
            bool[] visitados = new bool[grafo.getVertices().Count];
            List <Vertice <string> > camino      = new List <Vertice <string> >();
            List <Vertice <string> > mejorCamino = grafo.getVertices();

            this._minEncrucijadas(camino, origen, destino, visitados, mejorCamino);
            return(mejorCamino.Count - 1);
        }
        public List <Vertice <int> > ordenTopologico(Grafo <int> grafo)
        {
            bool[] visitados = new bool[grafo.getVertices().Count];
            List <Vertice <int> >  camino = new List <Vertice <int> >();
            Stack <Vertice <int> > pila   = new Stack <Vertice <int> >();

            foreach (var vertice in grafo.getVertices())
            {
                if (vertice.entradaCero())
                {
                    this._ordenTopologico(vertice, visitados, pila);
                }
            }
            while (pila.Count != 0)
            {
                camino.Add(pila.Pop());
            }
            return(camino);
        }
예제 #3
0
        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);
        }
예제 #4
0
        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 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);
		}