Print all paths from a given source to a destination using BFS

Last Updated : 18 Jul, 2024

Given a directed graph, a source vertex ‘src’ and a destination vertex ‘dst’, print all paths from given ‘src’ to ‘dst’. Please note that in the cases, we have cycles in the graph, we need not to consider paths have cycles as in case of cycles, there can by infinitely many by doing multiple iterations of a cycle. For simplicity, you may assume that there are no cycles in the input graph.

Consider the following directed graph. Let the src be 2 and dst be 3. There are 3 different paths from 2 to 3.

We have already discussed Print all paths from a given source to a destination using DFS.

Below is BFS based solution.

Algorithm :

create a queue which will store path(s) of type vector
initialise the queue with first path starting from src

Now run a loop till queue is not empty
   get the frontmost path from queue
   check if the lastnode of this path is destination
       if true then print the path
   run a loop for all the vertices connected to the
   current vertex i.e. lastnode extracted from path
      if the vertex is not visited in current path
         a) create a new path from earlier path and 
             append this vertex
         b) insert this new path to queue

Implementation:

C++

// C++ program to print all paths of source to
// destination in given graph
#include <bits/stdc++.h>
using namespace std;

// utility function for printing
// the found path in graph
void printpath(vector<int>& path)
{
    int size = path.size();
    for (int i = 0; i < size; i++)
        cout << path[i] << " ";
    cout << endl;
}

// utility function to check if current
// vertex is already present in path
int isNotVisited(int x, vector<int>& path)
{
    int size = path.size();
    for (int i = 0; i < size; i++)
        if (path[i] == x)
            return 0;
    return 1;
}

// utility function for finding paths in graph
// from source to destination
void findpaths(vector<vector<int> >& g, int src, int dst,
               int v)
{
    // create a queue which stores
    // the paths
    queue<vector<int> > q;

    // path vector to store the current path
    vector<int> path;
    path.push_back(src);
    q.push(path);
    while (!q.empty()) {
        path = q.front();
        q.pop();
        int last = path[path.size() - 1];

        // if last vertex is the desired destination
        // then print the path
        if (last == dst)
            printpath(path);

        // traverse to all the nodes connected to
        // current vertex and push new path to queue
        for (int i = 0; i < g[last].size(); i++) {
            if (isNotVisited(g[last][i], path)) {
                vector<int> newpath(path);
                newpath.push_back(g[last][i]);
                q.push(newpath);
            }
        }
    }
}

// driver program
int main()
{
    vector<vector<int> > g;
    // number of vertices
    int v = 4;
    g.resize(4);

    // construct a graph
    g[0].push_back(3);
    g[0].push_back(1);
    g[0].push_back(2);
    g[1].push_back(3);
    g[2].push_back(0);
    g[2].push_back(1);

    int src = 2, dst = 3;
    cout << "path from src " << src << " to dst " << dst
         << " are \n";

    // function for finding the paths
    findpaths(g, src, dst, v);

    return 0;
}

Java

// Java program to print all paths of source to
// destination in given graph
import java.io.*;
import java.util.*;

class Graph{

// utility function for printing
// the found path in graph
private static void printPath(List<Integer> path)
{
    int size = path.size();
    for(Integer v : path) 
    {
        System.out.print(v + " ");
    }
    System.out.println();
}

// Utility function to check if current
// vertex is already present in path
private static boolean isNotVisited(int x, 
                                    List<Integer> path)
{
    int size = path.size();
    for(int i = 0; i < size; i++)
        if (path.get(i) == x)
            return false;
            
    return true;
}

// Utility function for finding paths in graph
// from source to destination
private static void findpaths(List<List<Integer> > g, 
                              int src, int dst, int v)
{
    
    // Create a queue which stores
    // the paths
    Queue<List<Integer> > queue = new LinkedList<>();

    // Path vector to store the current path
    List<Integer> path = new ArrayList<>();
    path.add(src);
    queue.offer(path);
    
    while (!queue.isEmpty()) 
    {
        path = queue.poll();
        int last = path.get(path.size() - 1);

        // If last vertex is the desired destination
        // then print the path
        if (last == dst) 
        {
            printPath(path);
        }

        // Traverse to all the nodes connected to
        // current vertex and push new path to queue
        List<Integer> lastNode = g.get(last);
        for(int i = 0; i < lastNode.size(); i++)
        {
            if (isNotVisited(lastNode.get(i), path)) 
            {
                List<Integer> newpath = new ArrayList<>(path);
                newpath.add(lastNode.get(i));
                queue.offer(newpath);
            }
        }
    }
}

// Driver code
public static void main(String[] args)
{
    List<List<Integer> > g = new ArrayList<>();
    int v = 4;
    for(int i = 0; i < 4; i++) 
    {
        g.add(new ArrayList<>());
    }

    // Construct a graph
    g.get(0).add(3);
    g.get(0).add(1);
    g.get(0).add(2);
    g.get(1).add(3);
    g.get(2).add(0);
    g.get(2).add(1);
    int src = 2, dst = 3;
    System.out.println("path from src " + src + 
                       " to dst " + dst + " are ");
                       
    // Function for finding the paths                   
    findpaths(g, src, dst, v);
}
}

// This code is contributed by rajatsri94

Python

# Python3 program to print all paths of 
# source to destination in given graph
from typing import List
from collections import deque

# Utility function for printing
# the found path in graph
def printpath(path: List[int]) -> None:
    
    size = len(path)
    for i in range(size):
        print(path[i], end = " ")
        
    print()

# Utility function to check if current
# vertex is already present in path
def isNotVisited(x: int, path: List[int]) -> int:

    size = len(path)
    for i in range(size):
        if (path[i] == x):
            return 0
            
    return 1

# Utility function for finding paths in graph
# from source to destination
def findpaths(g: List[List[int]], src: int, 
              dst: int, v: int) -> None:
                  
    # Create a queue which stores
    # the paths
    q = deque()

    # Path vector to store the current path
    path = []
    path.append(src)
    q.append(path.copy())
    
    while q:
        path = q.popleft()
        last = path[len(path) - 1]

        # If last vertex is the desired destination
        # then print the path
        if (last == dst):
            printpath(path)

        # Traverse to all the nodes connected to
        # current vertex and push new path to queue
        for i in range(len(g[last])):
            if (isNotVisited(g[last][i], path)):
                newpath = path.copy()
                newpath.append(g[last][i])
                q.append(newpath)

# Driver code
if __name__ == "__main__":
    
    # Number of vertices
    v = 4
    g = [[] for _ in range(4)]

    # Construct a graph
    g[0].append(3)
    g[0].append(1)
    g[0].append(2)
    g[1].append(3)
    g[2].append(0)
    g[2].append(1)

    src = 2
    dst = 3
    print("path from src {} to dst {} are".format(
        src, dst))

    # Function for finding the paths
    findpaths(g, src, dst, v)

# This code is contributed by sanjeev2552

// C# program to print all paths of source to
// destination in given graph

using System;
using System.Collections.Generic;

public class Graph{

// utility function for printing
// the found path in graph
static void printPath(List<int> path)
{
    int size = path.Count;
    foreach(int v in path) 
    {
        Console.Write(v + " ");
    }
    Console.WriteLine();
}

// Utility function to check if current
// vertex is already present in path
static bool isNotVisited(int x, List<int> path)
{
    int size = path.Count;
    for(int i = 0; i < size; i++)
        if (path[i] == x)
            return false;
            
    return true;
}

// Utility function for finding paths in graph
// from source to destination
private static void findpaths(List<List<int> > g, 
                              int src, int dst, int v)
{
    
    // Create a queue which stores
    // the paths
    Queue<List<int> > queue = new Queue<List<int>>();

    // Path vector to store the current path
    List<int> path = new List<int>();
    path.Add(src);
    queue.Enqueue(path);
    
    while (queue.Count!=0) 
    {
        path = queue.Dequeue();
        int last = path[path.Count - 1];

        // If last vertex is the desired destination
        // then print the path
        if (last == dst) 
        {
            printPath(path);
        }

        // Traverse to all the nodes connected to
        // current vertex and push new path to queue
        List<int> lastNode = g[last];
        for(int i = 0; i < lastNode.Count; i++)
        {
            if (isNotVisited(lastNode[i], path)) 
            {
                List<int> newpath = new List<int>(path);
                newpath.Add(lastNode[i]);
                queue.Enqueue(newpath);
            }
        }
    }
}

// Driver code
public static void Main(String[] args)
{
    List<List<int> > g = new List<List<int>>();
    int v = 4;
    for(int i = 0; i < 4; i++) 
    {
        g.Add(new List<int>());
    }

    // Construct a graph
    g[0].Add(3);
    g[0].Add(1);
    g[0].Add(2);
    g[1].Add(3);
    g[2].Add(0);
    g[2].Add(1);
    int src = 2, dst = 3;
    Console.WriteLine("path from src " + src + 
                       " to dst " + dst + " are ");
                       
    // Function for finding the paths                   
    findpaths(g, src, dst, v);
}
}

// This code is contributed by shikhasingrajput

JavaScript

// JavaScript code to print all paths of 
// source to destination in given graph

// Utility function for printing
// the found path in graph
function printpath(path) {
    let size = path.length;
    for (let i = 0; i < size; i++) {
        process.stdout.write(path[i] + " ");
    }
    console.log();
}

// Utility function to check if current
// vertex is already present in path
function isNotVisited(x, path) {
    let size = path.length;
    for (let i = 0; i < size; i++) {
        if (path[i] === x) {
            return 0;
        }
    }
    return 1;
}

// Utility function for finding paths in graph
// from source to destination
function findpaths(g, src, dst, v) {
    // Create a queue which stores
    // the paths
    let q = [];

    // Path array to store the current path
    let path = [];
    path.push(src);
    q.push(path.slice());
    
    while (q.length) {
        path = q.shift();
        let last = path[path.length - 1];

        // If last vertex is the desired destination
        // then print the path
        if (last === dst) {
            printpath(path);
        }

        // Traverse to all the nodes connected to
        // current vertex and push new path to queue
        for (let i = 0; i < g[last].length; i++) {
            if (isNotVisited(g[last][i], path)) {
                let newpath = path.slice();
                newpath.push(g[last][i]);
                q.push(newpath);
            }
        }
    }
}

// Driver code

    // Number of vertices
    let v = 4;
    let g = Array.from({ length: 4 }, () => []);

    // Construct a graph
    g[0].push(3);
    g[0].push(1);
    g[0].push(2);
    g[1].push(3);
    g[2].push(0);
    g[2].push(1);

    let src = 2;
    let dst = 3;
    console.log(`path from src ${src} to dst ${dst} are`);

    // Function for finding the paths
    findpaths(g, src, dst, v);

Output

path from src 2 to dst 3 are 
2 0 3 
2 1 3 
2 0 1 3

Time Complexity: O(V^V), the time complexity is exponential. From each vertex there are v vertices that can be visited from current vertex.
Auxiliary space: O(V^V), as there can be V^Vpaths possible in the worst case.

Minimum steps to reach target by a Knight | Set 1

Mandeep Singh

Improve

Article Tags :

Practice Tags :

Print all paths from a given source to a destination using BFS

Similar Reads

BFS in different language

Variations of BFS implementations

Easy problems on BFS

Intermediate problems on BFS

Hard Problems on BFS

Thank You!

What kind of Experience do you want to share?