//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////// Dijktra's Algorithm //////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /** * This function will implement Dijkstra's Algorithm to find the shortest path to all the nodes from the source node * Time Complexity: O((|V| + |E|) log|V|) with a heap as it iterates over all the nodes and all the edges and uses a queue to go * through them where the heap queue has a worst case of log|V|. Whereas if the queue was implemented with an array, the complexity * would be O((|V|^2) since the queue has a worst case of |V| and |E| is upper bounded by |V|^2 and so |V|^2 dominates. * Space Complexity: O(|V|) as it creates arrays as big as the number of nodes in the graph */ private List <int> Dijkstras(ref PriorityQueue queue, bool isArray) { // Create Queue to track order of points queue.makeQueue(points.Count); // Set up prev node list List <int> prev = new List <int>(); List <double> dist = new List <double>(); for (int i = 0; i < points.Count; i++) { prev.Add(-1); dist.Add(double.MaxValue); } // Initilize the start node distance to 0 dist[startNodeIndex] = 0; // Update Priority Queue to reflect change in start point distance if (isArray) { queue.insert(startNodeIndex, 0); } else { queue.insert(ref dist, startNodeIndex); } // Iterate while the queue is not empty while (!queue.isEmpty()) { // Grab the next min cost Point int indexOfMin; if (isArray) { indexOfMin = queue.deleteMin(); } else { indexOfMin = queue.deleteMin(ref dist); } PointF u = points[indexOfMin]; // For all edges coming out of u foreach (int targetIndex in adjacencyList[indexOfMin]) { PointF target = points[targetIndex]; double newDist = dist[indexOfMin] + computeDistance(u, target); if (dist[targetIndex] > newDist) { prev[targetIndex] = indexOfMin; dist[targetIndex] = newDist; if (isArray) { queue.decreaseKey(targetIndex, newDist); } else { queue.decreaseKey(ref dist, targetIndex); } } } } return(prev); }
//-----------------------------------------------------------------------------// //-------------------------- Dijkstra's Algorithm -----------------------------// //-----------------------------------------------------------------------------// /** * This Dijkstra's is implemented based off of the pseudocode found in the text. * Time complexity for the Binary Heap Priority queue is O(|V| * |logV|) * because the implementation requires all the nodes to be visited but the * update methods require |log V| time. The array priority queue is O(|V|^2) * because it has to visit all the nodes on implementation and has to itterate * through the nodes in order to delete and update the queue. The space complexity * for both is O(|V|) because each queue stores all of the nodes generated **/ private List <int> dijkstrasAlgorithm(PriorityQueue queue, bool isArray) { queue.makeQueue(points.Count); List <int> previous = new List <int>(); List <double> distances = new List <double>(); // Sets all distance values to "infinity" // sets previous as 'undefined' for (int i = 0; i < points.Count; i++) { previous.Add(-1); distances.Add(double.MaxValue); } // distance to start node distances[startNodeIndex] = 0; // checks which priority queue will be used if (isArray) { queue.insert(startNodeIndex, 0); } else { queue.insert(ref distances, startNodeIndex); } // main loop // loops until there arent any nodes with a permanent distance to the end node while (!queue.isEmpty()) { int minIndex; if (isArray) { minIndex = queue.deleteMin(); } else { minIndex = queue.deleteMin(ref distances); } PointF u = points[minIndex]; // finds the best path amongst its neighbors, if it exists foreach (int index in adjacencyList[minIndex]) { PointF alt = points[index]; double altDistance = distances[minIndex] + distanceBetween(u, alt); if (altDistance < distances[index]) { previous[index] = minIndex; distances[index] = altDistance; if (isArray) { queue.decreaseKey(index, altDistance); } else { queue.decreaseKey(ref distances, index); } } } } //queue.printQueue(); // gives the path of the nodes return(previous); }