Esempio n. 1
0
        public void GeneratePath(List <Vertex> graphVertexes, Vertex destinationVertex)
        {
            DijkstraElement pathDijkstraElement;
            Edge            pathEdge;

            GetShortestPathsWithDijkstra(graphVertexes, destinationVertex);

            pathDijkstraElement = DijkstraElements.Find(DijkstraElement => DijkstraElement.IDVertex.Equals(destinationVertex));

            do
            {
                pathEdge = pathDijkstraElement.PreviousDijkstraElement.IDVertex.EdgeList.Find(Edge => Edge.Destination.Equals(pathDijkstraElement.IDVertex));

                if (pathEdge != null)
                {
                    Path.Enqueue(pathEdge);

                    pathDijkstraElement = pathDijkstraElement.PreviousDijkstraElement;
                }
            }while (!pathDijkstraElement.IDVertex.Equals(OriginVertex));

            Path = new Queue <Edge>(Path.Reverse());

            CurrentEdge = Path.Dequeue();
        }
Esempio n. 2
0
        // (N - 1)(N + log(N)) = (N^2 + Nlog(N) - N - log(N)) = O(N^2)
        private void UpdateDijkstraElements(DijkstraElement definitiveDijkstraElement)
        {
            int destinationIndex;

            foreach (Edge currentVertexEdge in definitiveDijkstraElement.IDVertex.EdgeList)
            {
                destinationIndex = DijkstraElements.FindIndex(DijkstraElement => DijkstraElement.IDVertex == currentVertexEdge.Destination);

                if (currentVertexEdge.Weight + definitiveDijkstraElement.AccumulatedDistance < DijkstraElements[destinationIndex].AccumulatedDistance)
                {
                    DijkstraElements[destinationIndex].AccumulatedDistance     = currentVertexEdge.Weight + definitiveDijkstraElement.AccumulatedDistance;
                    DijkstraElements[destinationIndex].PreviousDijkstraElement = definitiveDijkstraElement;

                    RelocateDijkstraElement(destinationIndex);
                }
            }
        }
Esempio n. 3
0
        // log(N)
        private void RelocateDijkstraElement(int index)
        {
            DijkstraElement temporalDijkstraElement = DijkstraElements[index];
            int             newIndex;

            DijkstraElements.RemoveAt(index);

            newIndex = DijkstraElements.BinarySearch(temporalDijkstraElement, new CompareDijkstraElementsByAccumulatedDistance());

            if (newIndex < 0)
            {
                DijkstraElements.Insert(~newIndex, temporalDijkstraElement);
            }
            else
            {
                DijkstraElements.Insert(newIndex, temporalDijkstraElement);
            }
        }
Esempio n. 4
0
        // N + log(N) + N(N^2) = N + log(N) + N^3 = O(N^3)
        private void GetShortestPathsWithDijkstra(List <Vertex> graphVertexes, Vertex destinationVertex)
        {
            int definitiveDijkstraElements = 0, originVertexIndex = OriginVertex.VertexCircle.ID - 1;

            foreach (Vertex currentVertex in graphVertexes)
            {
                DijkstraElements.Add(new DijkstraElement(currentVertex));
            }

            DijkstraElements[originVertexIndex].AccumulatedDistance     = 0;
            DijkstraElements[originVertexIndex].PreviousDijkstraElement = DijkstraElements[originVertexIndex];

            RelocateDijkstraElement(originVertexIndex);

            while (definitiveDijkstraElements != DijkstraElements.Count)
            {
                if (DijkstraElements[definitiveDijkstraElements].AccumulatedDistance == double.PositiveInfinity || DijkstraElements[definitiveDijkstraElements].IDVertex == destinationVertex)
                {
                    break;
                }

                UpdateDijkstraElements(DijkstraElements[definitiveDijkstraElements++]);
            }
        }