# 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

• 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.

Updated on: 14-Jul-2023

55 Views 