Dijkstra's Algorithm for 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.