Given a directed graph, design an algorithm to find out whether there is a route between two nodes.

Given a Directed Graph and two vertices in it, check whether there is a path from the first given vertex to second. For example, in the following graph, there is a path from vertex 1 to 3. As another example, there is no path from 3 to 0.
We can either use Breadth First Search (BFS) or Depth First Search (DFS) to find path between two vertices. Take the first vertex as source in BFS (or DFS), follow the standard BFS (or DFS). If we see the second vertex in our traversal, then return true. Else return false.
Following is C++ code that uses BFS for finding reachability of second vertex from first vertex.
// Program to check if there is exist a path between two vertices of a graph.
#include <list>
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
    Graph(int V);  // Constructor
    void addEdge(int v, int w); // function to add an edge to graph
    bool isReachable(int s, int d);  // returns true if there is a path from s to 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;
    // 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();
        // 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;
    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;
        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;
        cout<< "\n There is no path from " << u << " to " << v;
    return 0;
 There is a path from 1 to 3
 There is no path from 3 to 1
As an exercise, try an extended version of the problem where the complete path between two vertices is also needed.
Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above.


Popular posts from this blog

C Graph implementation with adjacency list representation using structures: Data Structure Tutorial 1

Interview with ACRush (Tiancheng Lou), the coding sensation!

Importing data to dynamoDB from S3 (using AWS Data Pipeline)