Print all paths from a given source to a destination

19 Jan, 2022
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. 
 
Approach: 
The idea is to do Depth First Traversal of given directed graph.Start the DFS traversal from source.Keep storing the visited vertices in an array or HashMap say ‘path[]’.If the destination vertex is reached, print contents of path[].The important thing is to mark current vertices in the path[] as visited also so that the traversal doesn’t go in a cycle.
The idea is to do Depth First Traversal of given directed graph.
Start the DFS traversal from source.
Keep storing the visited vertices in an array or HashMap say ‘path[]’.
If the destination vertex is reached, print contents of path[].
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 implementation of above idea.  
C++14
Java
Python3
C#
Javascript
// C++ program to print all paths// from a source to destination.#include <iostream>#include <list>using namespace std; // A directed graph using// adjacency list representationclass 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 programint 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 program to print all// paths from a source to// destination.import java.util.ArrayList;import java.util.List; // A directed graph using// adjacency list representationpublic class Graph {     // No. of vertices in graph    private int v;     // adjacency list    private ArrayList<Integer>[] 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<Integer> 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<Integer> 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.
# Python program to print all paths from a source to destination.  from collections import defaultdict  # This class represents a directed graph# using adjacency list representationclass 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 diagramg = 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 = 3print ("Following are all different paths from % d to % d :" %(s, d))g.printAllPaths(s, d)# This code is contributed by Neelam Yadav
// C# program to print all// paths from a source to// destination.using System;using System.Collections.Generic; // A directed graph using// adjacency list representationpublic 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
<script> // JavaScript program to print all// paths from a source to// destination. let  v; let adjList; // A directed graph using// adjacency list representationfunction Graph(vertices){    // initialise vertex count        v = vertices;          // initialise adjacency list        initAdjList();} // utility method to initialise    // adjacency listfunction initAdjList(){    adjList = new Array(v);          for (let i = 0; i < v; i++) {            adjList[i] = [];        }} // add edge from u to vfunction addEdge(u,v){    // Add v to u's list.        adjList[u].push(v);} // Prints all paths from    // 's' to 'd'function printAllPaths(s,d){     let isVisited = new Array(v);     for(let i=0;i<v;i++)         isVisited[i]=false;        let pathList = [];          // add source to path[]        pathList.push(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 pathfunction printAllPathsUtil(u,d,isVisited,localPathList){    if (u == (d)) {            document.write(localPathList+"<br>");            // 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 (let i=0;i< adjList[u].length;i++) {            if (!isVisited[adjList[u][i]]) {                // store current node                // in path[]                localPathList.push(adjList[u][i]);                printAllPathsUtil(adjList[u][i], d,                isVisited, localPathList);                  // remove current node                // in path[]                localPathList.splice(localPathList.indexOf                (adjList[u][i]),1);            }        }          // Mark the current node        isVisited[u] = false;}  // Driver program// Create a sample graphGraph(4);addEdge(0, 1);addEdge(0, 2);addEdge(0, 3);addEdge(2, 0);addEdge(2, 1);addEdge(1, 3); // arbitrary sourcelet s = 2; // arbitrary destinationlet d = 3; document.write("Following are all different paths from "+ s + " to " + d+"<Br>");printAllPaths(s, d);       // This code is contributed by avanitrachhadiya2155 </script>
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(V^V). The time complexity is polynomial. From each vertex there are v vertices that can be visited from current vertex.
Auxiliary space: O(V^V). To store the paths V^V space is needed.
This article is contributed by Shivam Gupta. Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above. 
sparsh singhal
Rajput-Ji
andrew1234
azatdzhanybekov
rskrish
avanitrachhadiya2155
amartyaghoshgfg
DFS
Backtracking
Graph
DFS
Graph
Backtracking
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.
Backtracking | Introduction
m Coloring Problem | Backtracking-5
Generate all the binary strings of N bits
Hamiltonian Cycle | Backtracking-6
Backtracking to find all subsets
Dijkstra's shortest path algorithm | Greedy Algo-7
Find if there is a path between two vertices in a directed graph
Prim’s Minimum Spanning Tree (MST) | Greedy Algo-5
Graph and its representations