 Open in App
Not now

# Find if there is a path between two vertices in a directed graph

• Difficulty Level : Easy
• Last Updated : 02 Feb, 2023

Given a Directed Graph and two vertices in it, check whether there is a path from the first given vertex to second.
Example:

```Consider the following Graph:

Input : (u, v) = (1, 3)
Output: Yes
Explanation: There is a path from 1 to 3, 1 -> 2 -> 3

Input : (u, v) = (3, 6)
Output: No
Explanation: There is no path from 3 to 6```

Approach: Either Breadth First Search (BFS) or Depth First Search (DFS) can be used to find path between two vertices. Take the first vertex as a source in BFS (or DFS), follow the standard BFS (or DFS). If the second vertex is found in our traversal, then return true else return false.

BFS Algorithm:

1. The implementation below is using BFS.
2. Create a queue and a visited array initially filled with 0, of size V where V is a number of vertices.
3. Insert the starting node in the queue, i.e. push u in the queue and mark u as visited.
4. Run a loop until the queue is not empty.
5. Dequeue the front element of the queue. Iterate all its adjacent elements. If any of the adjacent elements is the destination return true. Push all the adjacent and unvisited vertices in the queue and mark them as visited.
6. Return false as the destination is not reached in BFS.

Implementation: C++, Java, and Python codes that use BFS for finding the reachability of the second vertex from the first vertex.

## C++

 `// C++ program to check if there is exist a path between two vertices``// of a graph.``#include``#include ``using` `namespace` `std;` `// This class represents a directed graph using adjacency list``// representation``class` `Graph``{``    ``int` `V;    ``// No. of vertices``    ``list<``int``> *adj;    ``// Pointer to an array containing adjacency lists``public``:``    ``Graph(``int` `V);  ``// Constructor``    ``void` `addEdge(``int` `v, ``int` `w); ``// function to add an edge to graph``    ``bool` `isReachable(``int` `s, ``int` `d); ``};` `Graph::Graph(``int` `V)``{``    ``this``->V = V;``    ``adj = ``new` `list<``int``>[V];``}` `void` `Graph::addEdge(``int` `v, ``int` `w)``{``    ``adj[v].push_back(w); ``// Add w to v’s list.``}` `// A BFS based function to check whether d is reachable from s.``bool` `Graph::isReachable(``int` `s, ``int` `d)``{``    ``// Base case``    ``if` `(s == d)``      ``return` `true``;` `    ``// Mark all the vertices as not visited``    ``bool` `*visited = ``new` `bool``[V];``    ``for` `(``int` `i = 0; i < V; i++)``        ``visited[i] = ``false``;` `    ``// Create a queue for BFS``    ``list<``int``> queue;` `    ``// Mark the current node as visited and enqueue it``    ``visited[s] = ``true``;``    ``queue.push_back(s);` `    ``// it will be used to get all adjacent vertices of a vertex``    ``list<``int``>::iterator i;` `    ``while` `(!queue.empty())``    ``{``        ``// Dequeue a vertex from queue and print it``        ``s = queue.front();``        ``queue.pop_front();` `        ``// Get all adjacent vertices of the dequeued vertex s``        ``// If a adjacent has not been visited, then mark it visited``        ``// and enqueue it``        ``for` `(i = adj[s].begin(); i != adj[s].end(); ++i)``        ``{``            ``// If this adjacent node is the destination node, then``            ``// return true``            ``if` `(*i == d)``                ``return` `true``;` `            ``// Else, continue to do BFS``            ``if` `(!visited[*i])``            ``{``                ``visited[*i] = ``true``;``                ``queue.push_back(*i);``            ``}``        ``}``    ``}``    ` `    ``// If BFS is complete without visiting d``    ``return` `false``;``}` `// Driver program to test methods of graph class``int` `main()``{``    ``// Create a graph given in the above diagram``    ``Graph g(4);``    ``g.addEdge(0, 1);``    ``g.addEdge(0, 2);``    ``g.addEdge(1, 2);``    ``g.addEdge(2, 0);``    ``g.addEdge(2, 3);``    ``g.addEdge(3, 3);` `    ``int` `u = 1, v = 3;``    ``if``(g.isReachable(u, v))``        ``cout<< ``"\n There is a path from "` `<< u << ``" to "` `<< v;``    ``else``        ``cout<< ``"\n There is no path from "` `<< u << ``" to "` `<< v;` `    ``u = 3, v = 1;``    ``if``(g.isReachable(u, v))``        ``cout<< ``"\n There is a path from "` `<< u << ``" to "` `<< v;``    ``else``        ``cout<< ``"\n There is no path from "` `<< u << ``" to "` `<< v;` `    ``return` `0;``}`

## Java

 `// Java program to check if there is exist a path between two vertices``// of a graph.``import` `java.io.*;``import` `java.util.*;``import` `java.util.LinkedList;` `// This class represents a directed graph using adjacency list``// representation``class` `Graph``{``    ``private` `int` `V;   ``// No. of vertices``    ``private` `LinkedList adj[]; ``//Adjacency List` `    ``//Constructor``    ``Graph(``int` `v)``    ``{``        ``V = v;``        ``adj = ``new` `LinkedList[v];``        ``for` `(``int` `i=``0``; itemp;` `        ``// Mark all the vertices as not visited(By default set``        ``// as false)``        ``boolean` `visited[] = ``new` `boolean``[V];` `        ``// Create a queue for BFS``        ``LinkedList queue = ``new` `LinkedList();` `        ``// Mark the current node as visited and enqueue it``        ``visited[s]=``true``;``        ``queue.add(s);` `        ``// 'i' will be used to get all adjacent vertices of a vertex``        ``Iterator i;``        ``while` `(queue.size()!=``0``)``        ``{``            ``// Dequeue a vertex from queue and print it``            ``s = queue.poll();` `            ``int` `n;``            ``i = adj[s].listIterator();` `            ``// Get all adjacent vertices of the dequeued vertex s``            ``// If a adjacent has not been visited, then mark it``            ``// visited and enqueue it``            ``while` `(i.hasNext())``            ``{``                ``n = i.next();` `                ``// If this adjacent node is the destination node,``                ``// then return true``                ``if` `(n==d)``                    ``return` `true``;` `                ``// Else, continue to do BFS``                ``if` `(!visited[n])``                ``{``                    ``visited[n] = ``true``;``                    ``queue.add(n);``                ``}``            ``}``        ``}` `        ``// If BFS is complete without visited d``        ``return` `false``;``    ``}` `    ``// Driver method``    ``public` `static` `void` `main(String args[])``    ``{``        ``// Create a graph given in the above diagram``        ``Graph g = ``new` `Graph(``4``);``        ``g.addEdge(``0``, ``1``);``        ``g.addEdge(``0``, ``2``);``        ``g.addEdge(``1``, ``2``);``        ``g.addEdge(``2``, ``0``);``        ``g.addEdge(``2``, ``3``);``        ``g.addEdge(``3``, ``3``);` `        ``int` `u = ``1``;``        ``int` `v = ``3``;``        ``if` `(g.isReachable(u, v))``            ``System.out.println(``"There is a path from "` `+ u +``" to "` `+ v);``        ``else``            ``System.out.println(``"There is no path from "` `+ u +``" to "` `+ v);;` `        ``u = ``3``;``        ``v = ``1``;``        ``if` `(g.isReachable(u, v))``            ``System.out.println(``"There is a path from "` `+ u +``" to "` `+ v);``        ``else``            ``System.out.println(``"There is no path from "` `+ u +``" to "` `+ v);;``    ``}``}``// This code is contributed by Aakash Hasija`

## Python3

 `# program to check if there is exist a path between two vertices``# of a graph` `from` `collections ``import` `defaultdict`` ` `#This class represents a directed graph using adjacency list representation``class` `Graph:`` ` `    ``def` `__init__(``self``,vertices):``        ``self``.V``=` `vertices ``#No. of vertices``        ``self``.graph ``=` `defaultdict(``list``) ``# default dictionary to store graph`` ` `    ``# function to add an edge to graph``    ``def` `addEdge(``self``,u,v):``        ``self``.graph[u].append(v)``     ` `     ``# Use BFS to check path between s and d``    ``def` `isReachable(``self``, s, d):``        ``# Mark all the vertices as not visited``        ``visited ``=``[``False``]``*``(``self``.V)`` ` `        ``# Create a queue for BFS``        ``queue``=``[]`` ` `        ``# Mark the source node as visited and enqueue it``        ``queue.append(s)``        ``visited[s] ``=` `True`` ` `        ``while` `queue:` `            ``#Dequeue a vertex from queue``            ``n ``=` `queue.pop(``0``)``            ` `            ``# If this adjacent node is the destination node,``            ``# then return true``            ``if` `n ``=``=` `d:``                   ``return` `True` `            ``#  Else, continue to do BFS``            ``for` `i ``in` `self``.graph[n]:``                ``if` `visited[i] ``=``=` `False``:``                    ``queue.append(i)``                    ``visited[i] ``=` `True``         ``# If BFS is complete without visited d``        ``return` `False`` ` `# Create a graph given in the above diagram``g ``=` `Graph(``4``)``g.addEdge(``0``, ``1``)``g.addEdge(``0``, ``2``)``g.addEdge(``1``, ``2``)``g.addEdge(``2``, ``0``)``g.addEdge(``2``, ``3``)``g.addEdge(``3``, ``3``)` `u ``=``1``; v ``=` `3` `if` `g.isReachable(u, v):``    ``print``(``"There is a path from %d to %d"` `%` `(u,v))``else` `:``    ``print``(``"There is no path from %d to %d"` `%` `(u,v))` `u ``=` `3``; v ``=` `1``if` `g.isReachable(u, v) :``    ``print``(``"There is a path from %d to %d"` `%` `(u,v))``else` `:``    ``print``(``"There is no path from %d to %d"` `%` `(u,v))` `#This code is contributed by Neelam Yadav`

## C#

 `// C# program to check if there is``// exist a path between two vertices``// of a graph.``using` `System;``using` `System.Collections;``using` `System.Collections.Generic;` `// This class represents a directed``// graph using adjacency list``// representation``class` `Graph``{``  ``private` `int` `V; ``// No. of vertices``  ``private` `LinkedList<``int``>[] adj; ``//Adjacency List` `  ``// Constructor``  ``Graph(``int` `v)``  ``{``    ``V = v;``    ``adj = ``new` `LinkedList<``int``>[v];``    ``for` `(``int` `i = 0; i < v; ++i)``      ``adj[i] = ``new` `LinkedList<``int``>();``  ``}` `  ``// Function to add an edge into the graph``  ``void` `addEdge(``int` `v, ``int` `w)``  ``{``    ``adj[v].AddLast(w);``  ``}` `  ``// prints BFS traversal from a given source s``  ``bool` `isReachable(``int` `s, ``int` `d)``  ``{``    ``// LinkedList temp = new LinkedList();` `    ``// Mark all the vertices as not visited(By default set``    ``// as false)``    ``bool``[] visited = ``new` `bool``[V];` `    ``// Create a queue for BFS``    ``LinkedList<``int``> queue = ``new` `LinkedList<``int``>();` `    ``// Mark the current node as visited and enqueue it``    ``visited[s] = ``true``;``    ``queue.AddLast(s);` `    ``// 'i' will be used to get all adjacent vertices of a vertex``    ``IEnumerator i;     ``    ``while` `(queue.Count != 0)``    ``{` `      ``// Dequeue a vertex from queue and print it``      ``s = queue.First.Value;``      ``queue.RemoveFirst();``      ``int` `n;``      ``i = adj[s].GetEnumerator();` `      ``// Get all adjacent vertices of the dequeued vertex s``      ``// If a adjacent has not been visited, then mark it``      ``// visited and enqueue it``      ``while` `(i.MoveNext())``      ``{``        ``n = (``int``)i.Current;` `        ``// If this adjacent node is the destination node,``        ``// then return true``        ``if` `(n == d)``          ``return` `true``;` `        ``// Else, continue to do BFS``        ``if` `(!visited[n])``        ``{``          ``visited[n] = ``true``;``          ``queue.AddLast(n);``        ``}``      ``}``    ``}` `    ``// If BFS is complete without visited d``    ``return` `false``;``  ``}` `  ``// Driver method``  ``public` `static` `void` `Main(``string``[] args)``  ``{` `    ``// Create a graph given in the above diagram``    ``Graph g = ``new` `Graph(4);``    ``g.addEdge(0, 1);``    ``g.addEdge(0, 2);``    ``g.addEdge(1, 2);``    ``g.addEdge(2, 0);``    ``g.addEdge(2, 3);``    ``g.addEdge(3, 3);``    ``int` `u = 1;``    ``int` `v = 3;``    ``if` `(g.isReachable(u, v))``      ``Console.WriteLine(``"There is a path from "` `+ u + ``" to "` `+ v);``    ``else``      ``Console.WriteLine(``"There is no path from "` `+ u + ``" to "` `+ v);``    ``u = 3;``    ``v = 1;``    ``if` `(g.isReachable(u, v))``      ``Console.WriteLine(``"There is a path from "` `+ u + ``" to "` `+ v);``    ``else``      ``Console.WriteLine(``"There is no path from "` `+ u + ``" to "` `+ v);``  ``}``}` `// This code is contributed by sanjeev2552`

## Javascript

 ``

Output

``` There is a path from 1 to 3
There is no path from 3 to 1```

Complexity Analysis:

• Time Complexity: O(V+E) where V is number of vertices in the graph and E is number of edges in the graph.
• Space Complexity: O(V).
There can be atmost V elements in the queue. So the space needed is O(V).

DFS Algorithm:

1. if start==end return 1 since we have to reached our destination.
2. Mark start as visited.
3. Traverse directly connected vertices of start and recur the function dfs for every such unexplored vertex.
4. return 0 if we do not reach our destination.

Implementation:

## C++14

 `#include ``using` `namespace` `std;``typedef` `long` `long` `ll;` `vector adj;``bool` `visited;` `bool` `dfs(``int` `start, ``int` `end)``{``    ``if` `(start == end)``        ``return` `true``;``    ``visited[start] = 1;``    ``for` `(``auto` `x : adj[start]) {``        ``if` `(!visited[x])``            ``if` `(dfs(x, end))``                ``return` `true``;``    ``}``    ``return` `false``;``}` `int` `main()``{` `    ``int` `V = 4;``    ``vector members = { 2, 5, 7, 9 };` `    ``int` `E = 4;``    ``vector > connections``        ``= { { 2, 9 }, { 7, 2 }, { 7, 9 }, { 9, 5 } };` `    ``for` `(``int` `i = 0; i < E; i++)``        ``adj[connections[i].first].push_back(``            ``connections[i].second);` `    ``int` `sender = 7, receiver = 9;` `    ``if` `(dfs(sender, receiver))``        ``cout << ``"1"``;``    ``else``        ``cout << ``"0"``;` `    ``return` `0;``}``// this code is contributed by prophet1999`

## Python3

 `from` `typing ``import` `List``, ``Tuple` `def` `dfs(start: ``int``, end: ``int``, visited: ``List``[``bool``], V: ``int``) ``-``> ``bool``:``    ``if` `start ``=``=` `end:``        ``return` `True``    ``visited[start] ``=` `True``    ``for` `x ``in` `adj[start]:``        ``if` `not` `visited[x]:``            ``if` `dfs(x, end, visited, V):``                ``return` `True``    ``return` `False` `if` `__name__ ``=``=` `'__main__'``:``    ``V ``=` `4``    ``members ``=` `[``2``, ``5``, ``7``, ``9``]` `    ``E ``=` `4``    ``connections ``=` `[ (``2``, ``9``), (``7``, ``2``), (``7``, ``9``), (``9``, ``5``) ]` `    ``member_to_index ``=` `{member: i ``for` `i, member ``in` `enumerate``(members)}` `    ``adj ``=` `[[] ``for` `_ ``in` `range``(V)]``    ``for` `a, b ``in` `connections:``        ``a ``=` `member_to_index[a]``        ``b ``=` `member_to_index[b]``        ``adj[a].append(b)` `    ``sender ``=` `member_to_index[``7``]``    ``receiver ``=` `member_to_index[``9``]` `    ``visited ``=` `[``False``] ``*` `V``    ``if` `dfs(sender, receiver, visited, V):``        ``print``(``"1"``)``    ``else``:``        ``print``(``"0"``)`

## JavaScript

 `let adj = Array.from(Array(100000), () => ``new` `Array());``   ``let visited = ``new` `Array(100000);``   ``function` `dfs(start, end) {``     ``if` `(start == end) ``return` `true``;``     ``visited[start] = 1;``     ``for` `(y ``in` `adj[start]) {``       ``x = adj[start][y];``       ``if` `(!visited[x]) ``if` `(dfs(x, end)) ``return` `true``;``     ``}``     ``return` `false``;``   ``}` `   ``let V = 4;``   ``members = [2, 5, 7, 9];` `   ``let E = 4;``   ``connections = [``     ``[2, 9],``     ``[7, 2],``     ``[7, 9],``     ``[9, 5],``   ``];` `   ``for` `(let i = 0; i < E; i++)``     ``adj[connections[i]].push(connections[i]);` `   ``let sender = 7,``     ``receiver = 9;` `   ``if` `(dfs(sender, receiver)) console.log(``"1"``);``   ``else` `console.log(``"0"``);`

## Java

 `/*package whatever //do not write package name here */``import` `java.util.*;` `public` `class` `GFG {``    ` `    ``public` `static` `Vector adj[] = ``new` `Vector[``100000``];``    ``public` `static` `int``[] visited = ``new` `int``[``100000``];``    ` `    ``static` `boolean` `dfs(``int` `start, ``int` `end)``    ``{``        ``if` `(start == end){``            ``return` `true``;``        ``}` `        ``visited[start] = ``1``;``        ``for``(``int` `i = ``0``; i < adj[start].size(); i++){``            ``int` `x = adj[start].get(i);``            ``if` `(visited[x] == ``0``){``                ``if` `(dfs(x, end)){``                    ``return` `true``;``                ``}``            ``}``        ``}``        ``return` `false``;``    ``}``    ` `    ``public` `static` `void` `main(String[] args) {``        ``int` `V = ``4``;``        ``int``[] members = { ``2``, ``5``, ``7``, ``9` `};` `        ``int` `E = ``4``;``        ``int``[][] connections = { { ``2``, ``9` `}, { ``7``, ``2` `}, { ``7``, ``9` `}, { ``9``, ``5` `} };` `        ``for``(``int` `i =``0``;i<``100000``;i++) {``            ``adj[i] = ``new` `Vector<>();``        ``}``        ``for` `(``int` `i = ``0``; i < E; i++){``            ``// System.out.println(connections[i] + connections[i]);``            ``adj[connections[i][``0``]].add(connections[i][``1``]);``        ``}` `        ``int` `sender = ``7``;``        ``int` `receiver = ``9``;``        ` `        ``if` `(dfs(sender, receiver) == ``true``){``            ``System.out.println(``"1"``);``        ``}``        ``else``{``            ``System.out.println(``"0"``);``        ``}``    ``}``}` `// The code is contributed by Gautam goel.`

Output

`1`

Complexity Analysis:

Time Complexity: O(V+E) where V is number of vertices in the graph and E is number of edges in the graph.
Space Complexity: O(V).
There can be atmost V elements in the stack. So the space needed is O(V).