Open In App
Related Articles

Print all paths from a given source to a destination

Given a directed graph, a source vertex ‘s’ and a destination vertex ‘d’, print all paths from given ‘s’ to ‘d’.
Consider the following directed graph. Let the s be 2 and d be 3. There are 3 different paths from 2 to 3.

Recommended Practice

Approach:

1. The idea is to do Depth First Traversal of a given directed graph.
2. Start the DFS traversal from the source.
3. Keep storing the visited vertices in an array or HashMap say ‘path[]’.
4. If the destination vertex is reached, print the contents of path[].
5. The important thing is to mark current vertices in the path[] as visited also so that the traversal doesn’t go in a cycle.

Following is the implementation of the above idea.

C++14

 `// C++ program to print all paths``// from a source to destination.``#include ``#include ``using` `namespace` `std;` `// A directed graph using``// adjacency list representation``class` `Graph {``    ``int` `V; ``// No. of vertices in graph``    ``list<``int``>* adj; ``// Pointer to an array containing``                    ``// adjacency lists` `    ``// A recursive function used by printAllPaths()``    ``void` `printAllPathsUtil(``int``, ``int``, ``bool``[], ``int``[], ``int``&);` `public``:``    ``Graph(``int` `V); ``// Constructor``    ``void` `addEdge(``int` `u, ``int` `v);``    ``void` `printAllPaths(``int` `s, ``int` `d);``};` `Graph::Graph(``int` `V)``{``    ``this``->V = V;``    ``adj = ``new` `list<``int``>[V];``}` `void` `Graph::addEdge(``int` `u, ``int` `v)``{``    ``adj[u].push_back(v); ``// Add v to u’s list.``}` `// Prints all paths from 's' to 'd'``void` `Graph::printAllPaths(``int` `s, ``int` `d)``{``    ``// Mark all the vertices as not visited``    ``bool``* visited = ``new` `bool``[V];` `    ``// Create an array to store paths``    ``int``* path = ``new` `int``[V];``    ``int` `path_index = 0; ``// Initialize path[] as empty` `    ``// Initialize all vertices as not visited``    ``for` `(``int` `i = 0; i < V; i++)``        ``visited[i] = ``false``;` `    ``// Call the recursive helper function to print all paths``    ``printAllPathsUtil(s, d, visited, path, path_index);``}` `// A recursive function to print all paths from 'u' to 'd'.``// visited[] keeps track of vertices in current path.``// path[] stores actual vertices and path_index is current``// index in path[]``void` `Graph::printAllPathsUtil(``int` `u, ``int` `d, ``bool` `visited[],``                              ``int` `path[], ``int``& path_index)``{``    ``// Mark the current node and store it in path[]``    ``visited[u] = ``true``;``    ``path[path_index] = u;``    ``path_index++;` `    ``// If current vertex is same as destination, then print``    ``// current path[]``    ``if` `(u == d) {``        ``for` `(``int` `i = 0; i < path_index; i++)``            ``cout << path[i] << ``" "``;``        ``cout << endl;``    ``}``    ``else` `// If current vertex is not destination``    ``{``        ``// Recur for all the vertices adjacent to current``        ``// vertex``        ``list<``int``>::iterator i;``        ``for` `(i = adj[u].begin(); i != adj[u].end(); ++i)``            ``if` `(!visited[*i])``                ``printAllPathsUtil(*i, d, visited, path,``                                  ``path_index);``    ``}` `    ``// Remove current vertex from path[] and mark it as``    ``// unvisited``    ``path_index--;``    ``visited[u] = ``false``;``}` `// Driver program``int` `main()``{``    ``// Create a graph given in the above diagram``    ``Graph g(4);``    ``g.addEdge(0, 1);``    ``g.addEdge(0, 2);``    ``g.addEdge(0, 3);``    ``g.addEdge(2, 0);``    ``g.addEdge(2, 1);``    ``g.addEdge(1, 3);` `    ``int` `s = 2, d = 3;``    ``cout << ``"Following are all different paths from "` `<< s``         ``<< ``" to "` `<< d << endl;``    ``g.printAllPaths(s, d);` `    ``return` `0;``}`

Java

 `// JAVA program to print all``// paths from a source to``// destination.``import` `java.util.ArrayList;``import` `java.util.List;` `// A directed graph using``// adjacency list representation``public` `class` `Graph {` `    ``// No. of vertices in graph``    ``private` `int` `v;` `    ``// adjacency list``    ``private` `ArrayList[] adjList;` `    ``// Constructor``    ``public` `Graph(``int` `vertices)``    ``{` `        ``// initialise vertex count``        ``this``.v = vertices;` `        ``// initialise adjacency list``        ``initAdjList();``    ``}` `    ``// utility method to initialise``    ``// adjacency list``    ``@SuppressWarnings``(``"unchecked"``)``    ``private` `void` `initAdjList()``    ``{``        ``adjList = ``new` `ArrayList[v];` `        ``for` `(``int` `i = ``0``; i < v; i++) {``            ``adjList[i] = ``new` `ArrayList<>();``        ``}``    ``}` `    ``// add edge from u to v``    ``public` `void` `addEdge(``int` `u, ``int` `v)``    ``{``        ``// Add v to u's list.``        ``adjList[u].add(v);``    ``}` `    ``// Prints all paths from``    ``// 's' to 'd'``    ``public` `void` `printAllPaths(``int` `s, ``int` `d)``    ``{``        ``boolean``[] isVisited = ``new` `boolean``[v];``        ``ArrayList pathList = ``new` `ArrayList<>();` `        ``// add source to path[]``        ``pathList.add(s);` `        ``// Call recursive utility``        ``printAllPathsUtil(s, d, isVisited, pathList);``    ``}` `    ``// A recursive function to print``    ``// all paths from 'u' to 'd'.``    ``// isVisited[] keeps track of``    ``// vertices in current path.``    ``// localPathList<> stores actual``    ``// vertices in the current path``    ``private` `void` `printAllPathsUtil(Integer u, Integer d,``                                   ``boolean``[] isVisited,``                                   ``List localPathList)``    ``{` `        ``if` `(u.equals(d)) {``            ``System.out.println(localPathList);``            ``// if match found then no need to traverse more till depth``            ``return``;``        ``}` `        ``// Mark the current node``        ``isVisited[u] = ``true``;` `        ``// Recur for all the vertices``        ``// adjacent to current vertex``        ``for` `(Integer i : adjList[u]) {``            ``if` `(!isVisited[i]) {``                ``// store current node``                ``// in path[]``                ``localPathList.add(i);``                ``printAllPathsUtil(i, d, isVisited, localPathList);` `                ``// remove current node``                ``// in path[]``                ``localPathList.remove(i);``            ``}``        ``}` `        ``// Mark the current node``        ``isVisited[u] = ``false``;``    ``}` `    ``// Driver program``    ``public` `static` `void` `main(String[] args)``    ``{``        ``// Create a sample graph``        ``Graph g = ``new` `Graph(``4``);``        ``g.addEdge(``0``, ``1``);``        ``g.addEdge(``0``, ``2``);``        ``g.addEdge(``0``, ``3``);``        ``g.addEdge(``2``, ``0``);``        ``g.addEdge(``2``, ``1``);``        ``g.addEdge(``1``, ``3``);` `        ``// arbitrary source``        ``int` `s = ``2``;` `        ``// arbitrary destination``        ``int` `d = ``3``;` `        ``System.out.println(``            ``"Following are all different paths from "``            ``+ s + ``" to "` `+ d);``        ``g.printAllPaths(s, d);``    ``}``}` `// This code is contributed by Himanshu Shekhar.`

Python3

 `# Python program to print all paths from a source to destination.`` ` `from` `collections ``import` `defaultdict`` ` `# This class represents a directed graph``# using adjacency list representation``class` `Graph:`` ` `    ``def` `__init__(``self``, vertices):``        ``# No. of vertices``        ``self``.V ``=` `vertices``        ` `        ``# default dictionary to store graph``        ``self``.graph ``=` `defaultdict(``list``)`` ` `    ``# function to add an edge to graph``    ``def` `addEdge(``self``, u, v):``        ``self``.graph[u].append(v)`` ` `    ``'''A recursive function to print all paths from 'u' to 'd'.``    ``visited[] keeps track of vertices in current path.``    ``path[] stores actual vertices and path_index is current``    ``index in path[]'''``    ``def` `printAllPathsUtil(``self``, u, d, visited, path):` `        ``# Mark the current node as visited and store in path``        ``visited[u]``=` `True``        ``path.append(u)` `        ``# If current vertex is same as destination, then print``        ``# current path[]``        ``if` `u ``=``=` `d:``            ``print` `(path)``        ``else``:``            ``# If current vertex is not destination``            ``# Recur for all the vertices adjacent to this vertex``            ``for` `i ``in` `self``.graph[u]:``                ``if` `visited[i]``=``=` `False``:``                    ``self``.printAllPathsUtil(i, d, visited, path)``                    ` `        ``# Remove current vertex from path[] and mark it as unvisited``        ``path.pop()``        ``visited[u]``=` `False`` ` ` ` `    ``# Prints all paths from 's' to 'd'``    ``def` `printAllPaths(``self``, s, d):` `        ``# Mark all the vertices as not visited``        ``visited ``=``[``False``]``*``(``self``.V)` `        ``# Create an array to store paths``        ``path ``=` `[]` `        ``# Call the recursive helper function to print all paths``        ``self``.printAllPathsUtil(s, d, visited, path)`` ` ` ` ` ` `# Create a graph given in the above diagram``g ``=` `Graph(``4``)``g.addEdge(``0``, ``1``)``g.addEdge(``0``, ``2``)``g.addEdge(``0``, ``3``)``g.addEdge(``2``, ``0``)``g.addEdge(``2``, ``1``)``g.addEdge(``1``, ``3``)`` ` `s ``=` `2` `; d ``=` `3``print` `(``"Following are all different paths from % d to % d :"` `%``(s, d))``g.printAllPaths(s, d)``# This code is contributed by Neelam Yadav`

C#

 `// C# program to print all``// paths from a source to``// destination.``using` `System;``using` `System.Collections.Generic;` `// A directed graph using``// adjacency list representation``public` `class` `Graph {` `    ``// No. of vertices in graph``    ``private` `int` `v;` `    ``// adjacency list``    ``private` `List<``int``>[] adjList;` `    ``// Constructor``    ``public` `Graph(``int` `vertices)``    ``{` `        ``// initialise vertex count``        ``this``.v = vertices;` `        ``// initialise adjacency list``        ``initAdjList();``    ``}` `    ``// utility method to initialise``    ``// adjacency list``    ``private` `void` `initAdjList()``    ``{``        ``adjList = ``new` `List<``int``>[v];` `        ``for` `(``int` `i = 0; i < v; i++) {``            ``adjList[i] = ``new` `List<``int``>();``        ``}``    ``}` `    ``// add edge from u to v``    ``public` `void` `addEdge(``int` `u, ``int` `v)``    ``{``        ``// Add v to u's list.``        ``adjList[u].Add(v);``    ``}` `    ``// Prints all paths from``    ``// 's' to 'd'``    ``public` `void` `printAllPaths(``int` `s, ``int` `d)``    ``{``        ``bool``[] isVisited = ``new` `bool``[v];``        ``List<``int``> pathList = ``new` `List<``int``>();` `        ``// add source to path[]``        ``pathList.Add(s);` `        ``// Call recursive utility``        ``printAllPathsUtil(s, d, isVisited, pathList);``    ``}` `    ``// A recursive function to print``    ``// all paths from 'u' to 'd'.``    ``// isVisited[] keeps track of``    ``// vertices in current path.``    ``// localPathList<> stores actual``    ``// vertices in the current path``    ``private` `void` `printAllPathsUtil(``int` `u, ``int` `d,``                                   ``bool``[] isVisited,``                                   ``List<``int``> localPathList)``    ``{` `        ``if` `(u.Equals(d)) {``            ``Console.WriteLine(``string``.Join(``" "``, localPathList));``            ``// if match found then no need``            ``// to traverse more till depth``            ``return``;``        ``}` `        ``// Mark the current node``        ``isVisited[u] = ``true``;` `        ``// Recur for all the vertices``        ``// adjacent to current vertex``        ``foreach``(``int` `i ``in` `adjList[u])``        ``{``            ``if` `(!isVisited[i]) {``                ``// store current node``                ``// in path[]``                ``localPathList.Add(i);``                ``printAllPathsUtil(i, d, isVisited,``                                  ``localPathList);` `                ``// remove current node``                ``// in path[]``                ``localPathList.Remove(i);``            ``}``        ``}` `        ``// Mark the current node``        ``isVisited[u] = ``false``;``    ``}` `    ``// Driver code``    ``public` `static` `void` `Main(String[] args)``    ``{``        ``// Create a sample graph``        ``Graph g = ``new` `Graph(4);``        ``g.addEdge(0, 1);``        ``g.addEdge(0, 2);``        ``g.addEdge(0, 3);``        ``g.addEdge(2, 0);``        ``g.addEdge(2, 1);``        ``g.addEdge(1, 3);` `        ``// arbitrary source``        ``int` `s = 2;` `        ``// arbitrary destination``        ``int` `d = 3;` `        ``Console.WriteLine(``"Following are all different"``                          ``+ ``" paths from "` `+ s + ``" to "` `+ d);``        ``g.printAllPaths(s, d);``    ``}``}` `// This code contributed by Rajput-Ji`

Javascript

 ``

Output

```Following are all different paths from 2 to 3
2 0 1 3
2 0 3
2 1 3 ```

Complexity Analysis:

• Time Complexity: O(2^V), The time complexity is exponential. Given a source and destination, the source and destination nodes are going to be in every path. Depending upon edges, taking the worst case where every node has a directed edge to every other node, there can be at max 2^V different paths possible in the directed graph from a given source to destination.
• Auxiliary space: O(2^V), To store the paths 2^V space is needed.