Data Structure
Networking
RDBMS
Operating System
Java
MS Excel
iOS
HTML
CSS
Android
Python
C Programming
C++
C#
MongoDB
MySQL
Javascript
PHP
Physics
Chemistry
Biology
Mathematics
English
Economics
Psychology
Social Studies
Fashion Studies
Legal Studies
- Selected Reading
- UPSC IAS Exams Notes
- Developer's Best Practices
- Questions and Answers
- Effective Resume Writing
- HR Interview Questions
- Computer Glossary
- Who is Who
D’Esopo-Pape Algorithm : Single Source Shortest Path
The D'Esopo−Pape technique works with a single source vertex as a starting point to find the shortest path between that vertex and all other vertices in a directed graph. This method outperforms the conventional Bellman−Ford approach for charts with negative edge weights. During execution, this technique swiftly chooses the vertices that are spaced the closest together using a priority queue.
By iteratively relaxing edges and updating distances when a shorter path is identified, the D'Esopo−Pape method finds the shortest pathways in a graph. The approach optimises efficiency and reduces needless calculations by using a priority queue to choose the vertices with the least tentative distances.Among the many uses for the D'Esopo−Pape algorithm are those in computer networking, transportation planning, and data centre routing.
Methods Used
D’Esopo−pape Algorithm
D’Esopo−Pape Algorithm
The D'Esopo−Pape method iteratively relaxes edges and updates distances to find a graph's shortest pathways. The approach saves superfluous calculations and increases efficiency by selecting vertices with the least tentative distances using a priority queue.
Algorithm
Start with a directed graph having numVertices vertices.
Initialise a distance array distance of size numVertices and set all distances to infinity except the source vertex, which is 0.
Create a priority queue pq for vertices and tentative distances in increasing order. Insert the zero−distance source vertex into pq.
Do this if pq is not empty:
Find the vertex u closest to pq.
For each u−outgoing edge:
v is e's destination vertex.
Update distance[v] to distance[u] + weight if it is less than distance[v]. Insert or update the vertex v with its revised tentative distance in pq.
Print the source vertex's shortest distances.
Example
#include <iostream>
#include <vector>
#include <queue>
#include <climits>
// Structure to represent a directed edge
struct Edge {
int source, destination, weight;
};
// Function to compute single-source shortest paths using D'Esopo-Pape algorithm
void shortestPaths(const std::vector<Edge>& edges, int numVertices, int source) {
std::vector<int> distance(numVertices, INT_MAX); // Initialize distances to infinity
distance[source] = 0; // Distance from source to itself is 0
// Priority queue to store vertices with their tentative distances
std::priority_queue<std::pair<int, int>, std::vector<std::pair<int, int>>, std::greater<std::pair<int, int>>> pq;
pq.push(std::make_pair(distance[source], source));
while (!pq.empty()) {
int u = pq.top().second;
pq.pop();
// Traverse all adjacent vertices of u
for (const Edge& edge : edges) {
int v = edge.destination;
int weight = edge.weight;
// Relax the edge if a shorter path is found
if (distance[u] + weight < distance[v]) {
distance[v] = distance[u] + weight;
pq.push(std::make_pair(distance[v], v));
}
}
}
// Print the shortest distances from the source
std::cout << "Shortest distances from source " << source << ":\n";
for (int i = 0; i < numVertices; ++i) {
std::cout << "Vertex " << i << ": " << distance[i] << '\n';
}
}
int main() {
// Example usage
int numVertices = 5;
std::vector<Edge> edges = {
{0, 1, 10},
{0, 2, 5},
{1, 3, 1},
{2, 1, 3},
{2, 3, 9},
{2, 4, 2},
{3, 4, 4},
{4, 3, 6}
};
int source = 0;
shortestPaths(edges, numVertices, source);
return 0;
}
Output
Shortest distances from source 0: Vertex 0: 0 Vertex 1: 3 Vertex 2: 5 Vertex 3: 1 Vertex 4: 2
Conclusion
Finally, the D'Esopo−Pape method solves the directed graph single−source shortest path issue. The method effectively uses a priority queue and iteratively relaxing edges to calculate the shortest paths between a source vertex and all graph vertices.The shortest route algorithms developed by Dijkstra and Bellman−Ford cannot handle negative edge weights. This makes it suited for many real−world situations where edge weights imply costs or penalties.The D'Esopo−Pape algorithm optimises efficiency and accuracy while minimising calculations. Transportation, computing, and financial networks can use it.The D'Esopo−Pape algorithm helps us plan routes, optimise networks, and allocate resources. It solves complicated shortest route problems by handling directed graphs with negative weights well.
101 Views
