Shortest paths from all vertices to a destination - GeeksforGeeks

14 Jun, 2021
Given a Weighted Directed Graph and a destination vertex in the graph, find the shortest distance from all vertex to the destination vertex.Input :  
1
Output : 0 6 10 7 5Distance of 0 from 0: 0 Distance of 0 from 1: 1+5 = 6 (1->4->0) Distance of 0 from 2: 10 (2->0) Distance of 0 from 3: 1+1+5 = 7 (3->1->4->0) Distance of 0 from 4: 5 (4->0) 
Approach: The problem is similar to the Dijkstra’s problem..The idea is to use Dijkstra’s algorithm. In order to find the shortest distance from all vertex to a given destination vertex we reverse all the edges of the directed graph and use the destination vertex as the source vertex in dijkstra’s algorithm. Since all the edges are now reversed computing the shortest distance from the destination vertex to all the other vertex is similar to computing shortest distance from all vertex to a given destination vertex.After reversing the edges the graph looks like:  
Now calculate the shortest distance from the destination vertex as source vertex in Dijkstra’s algorithm.Below is the implementation of the above approach: 
CPP
Python3
// C++ implementation for the above approach#include <bits/stdc++.h>using namespace std;#define INF 0x3f3f3f3f // iPair ==>  Integer Pairtypedef pair<int, int> iPair; // This class represents a directed graph using// adjacency list representationclass Graph {    int V; // No. of vertices     // In a weighted graph, we need to store vertex    // and weight pair for every edge    list<pair<int, int> >* adj; public:    Graph(int V); // Constructor     // function to add an reverse edge to graph    void addEdgeRev(int u, int v, int w);     // prints shortest distance from all    // vertex to the given destination vertex    void shortestPath(int s);}; // Allocates memory for adjacency listGraph::Graph(int V){    this->V = V;    adj = new list<iPair>[V];} void Graph::addEdgeRev(int u, int v, int w){     adj[v].push_back(make_pair(u, w));} // Prints shortest distance from all vertex to// the given destination vertexvoid Graph::shortestPath(int dest){    // Create a priority queue to store vertices that    // are being preprocessed. This is weird syntax in C++.    // Refer below link for details of this syntax    // https:// www.geeksforgeeks.org/implement-min-heap-using-stl/    priority_queue<iPair, vector<iPair>, greater<iPair> > pq;     // Create a vector for distances and initialize all    // distances as infinite (INF)    vector<int> dist(V, INF);     // Insert destination itself in priority queue and initialize    // its distance as 0.    pq.push(make_pair(0, dest));    dist[dest] = 0;     /* Looping till priority queue becomes empty (or all      distances are not finalized) */    while (!pq.empty()) {         // The first vertex in pair is the minimum distance        // vertex, extract it from priority queue.        // vertex label is stored in second of pair (it        // has to be done this way to keep the vertices        // sorted distance (distance must be first item        // in pair)        int u = pq.top().second;        pq.pop();         // 'i' is used to get all adjacent vertices of a vertex        list<pair<int, int> >::iterator i;        for (i = adj[u].begin(); i != adj[u].end(); ++i) {             // Get vertex label and weight of current adjacent            // of u.            int v = (*i).first;            int weight = (*i).second;             // If there is shorted path to v through u.            if (dist[v] > dist[u] + weight) {                // Updating distance of v                dist[v] = dist[u] + weight;                pq.push(make_pair(dist[v], v));            }        }    }     // Print shortest distances stored in dist[]    printf("Destination Vertex Distance "           "from all vertex\n");    for (int i = 0; i < V; ++i)        printf("%d \t\t %d\n", i, dist[i]);} // Driver program to test methods of graph classint main(){    // create the graph given in above figure    int V = 5;    Graph g(V);     // adding edges in reverse direction    g.addEdgeRev(0, 2, 1);    g.addEdgeRev(0, 4, 5);    g.addEdgeRev(1, 4, 1);    g.addEdgeRev(2, 0, 10);    g.addEdgeRev(2, 3, 5);    g.addEdgeRev(3, 1, 1);    g.addEdgeRev(4, 0, 5);    g.addEdgeRev(4, 2, 100);    g.addEdgeRev(4, 3, 5);     g.shortestPath(0);     return 0;}
from queue import PriorityQueueINF = int(0x3f3f3f3f) # This class represents a directed graph using# adjacency list representationclass Graph:    def __init__(self, V: int) -> None:         self.V = V        # No. of vertices         # In a weighted graph, we need to store vertex        # and weight pair for every edge        self.adj = [[] for _ in range(V)]    def addEdgeRev(self, u: int, v: int, w: int) -> None:        self.adj[v].append((u, w))     # Prints shortest distance from all vertex to    # the given destination vertex    def shortestPath(self, dest: int) -> None:         # Create a priority queue to store vertices that        # are being preprocessed. This is weird syntax in C++.        # Refer below link for details of this syntax        # https:# www.geeksforgeeks.org/implement-min-heap-using-stl/        pq = PriorityQueue()         # Create a vector for distances and initialize all        # distances as infinite (INF)        dist = [INF for _ in range(V)]         # Insert destination itself in priority queue and initialize        # its distance as 0.        pq.put((0, dest))        dist[dest] = 0         # Looping till priority queue becomes empty (or all        # distances are not finalized) */        while not pq.empty():             # The first vertex in pair is the minimum distance            # vertex, extract it from priority queue.            # vertex label is stored in second of pair (it            # has to be done this way to keep the vertices            # sorted distance (distance must be first item            # in pair)            u = pq.get()[1]             # 'i' is used to get all adjacent vertices of a vertex            for i in self.adj[u]:                 # Get vertex label and weight of current adjacent                # of u.                v = i[0]                weight = i[1]                 # If there is shorted path to v through u.                if (dist[v] > dist[u] + weight):                                         # Updating distance of v                    dist[v] = dist[u] + weight                    pq.put((dist[v], v))         # Print shortest distances stored in dist[]        print("Destination Vertex Distance from all vertex")        for i in range(V):            print("{} \t\t {}".format(i, dist[i])) # Driver codeif __name__ == "__main__":     # create the graph given in above figure    V = 5    g = Graph(V)     # adding edges in reverse direction    g.addEdgeRev(0, 2, 1)    g.addEdgeRev(0, 4, 5)    g.addEdgeRev(1, 4, 1)    g.addEdgeRev(2, 0, 10)    g.addEdgeRev(2, 3, 5)    g.addEdgeRev(3, 1, 1)    g.addEdgeRev(4, 0, 5)    g.addEdgeRev(4, 2, 100)    g.addEdgeRev(4, 3, 5)     g.shortestPath(0) # This code is contributed by sanjeev2552
Destination Vertex Distance from all vertex
0                0
1                6
2                10
3                7
4                5         
 
sanjeev2552
umairalam94
Dijkstra
Shortest Path
Graph
Graph
Shortest Path
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.
Comments
Old Comments
Vertex Cover Problem | Set 1 (Introduction and Approximate Algorithm)
Graph Coloring | Set 2 (Greedy Algorithm)
Best First Search (Informed Search)
Uniform-Cost Search (Dijkstra for large Graphs)
Shortest Path in a weighted Graph where weight of an edge is 1 or 2
Iterative Deepening Search(IDS) or Iterative Deepening Depth First Search(IDDFS)
Travelling Salesman Problem implementation using BackTracking
Find if there is a path between two vertices in a directed graph
Longest Path in a Directed Acyclic Graph
Kruskal's Minimum Spanning Tree using STL in C++