예제 #1
0
        public void AddAdjacencia(string nodeName, string nodeAdjacente, double cost)
        {
            DijkstraNode node = GetNodeFromVertice(nodeName);
            var          aux  = GetNodeFromVertice(nodeAdjacente);

            node.Adjacencias.Add(new DijkstraNode()
            {
                Name = aux.Name, Adjacencias = null, Cost = cost
            });
        }
예제 #2
0
        public void Dijkstra(string nodoInicial, string nodoFinal)
        {
            PathCost = 0;
            Y        = new Dictionary <string, double?>();
            Path     = new Dictionary <string, string>();

            DijkstraNode nodoAux = null;
            double?      menor   = double.MaxValue;

            foreach (DijkstraNode nodo in Vertices)
            {
                if (nodo.Name.Equals(nodoInicial))
                {
                    Y.Add(nodo.Name, 0);
                }
                else
                {
                    Y.Add(nodo.Name, null);
                }
            }

            T       = Vertices.ToList();
            nodoAux = null;

            while (true)
            {
                foreach (DijkstraNode elementoT in T)
                {
                    if (GetValueFromY(elementoT.Name) != null)
                    {
                        if (GetValueFromY(elementoT.Name) < menor)
                        {
                            menor   = GetValueFromY(elementoT.Name);
                            nodoAux = elementoT;
                        }
                    }
                }

                if (nodoAux.Name.Equals(nodoFinal))
                {
                    GeneratePath(nodoInicial, nodoFinal);
                    return;
                }

                foreach (DijkstraNode nodoAdjacente in nodoAux.Adjacencias)
                {
                    if (ContainsInT(nodoAdjacente.Name))
                    {
                        if (GetValueFromY(nodoAdjacente.Name) == null)
                        {
                            Y[nodoAdjacente.Name] = nodoAdjacente.Cost + ((GetValueFromY(nodoAux.Name) == null)
                                                    ? 0 : GetValueFromY(nodoAux.Name));
                            Path.Add(nodoAdjacente.Name, nodoAux.Name);
                            continue;
                        }

                        if (GetValueFromY(nodoAdjacente.Name) > (GetValueFromY(nodoAux.Name) + nodoAdjacente.Cost))
                        {
                            Y[nodoAdjacente.Name] = GetValueFromY(nodoAux.Name) + nodoAdjacente.Cost;

                            if (Path.ContainsKey(nodoAdjacente.Name))
                            {
                                //Verificar porque nao esta removendo
                                Path.Remove(nodoAdjacente.Name);
                            }
                            Path.Add(nodoAdjacente.Name, nodoAux.Name);
                        }
                    }
                }
                T.Remove(T.First(c => c.Name.Equals(nodoAux.Name)));
                menor = int.MaxValue;
            }
        }